@aws-amplify/core

  • Version 5.8.5
  • Published
  • 1.33 MB
  • 10 dependencies
  • Apache-2.0 license

Install

npm i @aws-amplify/core
yarn add @aws-amplify/core
pnpm add @aws-amplify/core

Overview

Core category of aws-amplify

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Variables

variable Amplify

const Amplify: AmplifyClass;

    variable AppState

    const AppState: { addEventListener: (action: any, handler: any) => any };

      variable AsyncStorage

      const AsyncStorage: any;

        variable AWS_CLOUDWATCH_BASE_BUFFER_SIZE

        const AWS_CLOUDWATCH_BASE_BUFFER_SIZE: number;

          variable AWS_CLOUDWATCH_CATEGORY

          const AWS_CLOUDWATCH_CATEGORY: string;

            variable AWS_CLOUDWATCH_MAX_BATCH_EVENT_SIZE

            const AWS_CLOUDWATCH_MAX_BATCH_EVENT_SIZE: number;

              variable AWS_CLOUDWATCH_MAX_EVENT_SIZE

              const AWS_CLOUDWATCH_MAX_EVENT_SIZE: number;

                variable AWS_CLOUDWATCH_PROVIDER_NAME

                const AWS_CLOUDWATCH_PROVIDER_NAME: string;

                  variable Constants

                  const Constants: { userAgent: string };

                    variable Credentials

                    const Credentials: CredentialsClass;

                      variable DateUtils

                      const DateUtils: any;
                      • Date & time utility functions to abstract the aws-sdk away from users. (v2 => v3 modularization is a breaking change)

                        See Also

                        • https://github.com/aws/aws-sdk-js/blob/6edf586dcc1de7fe8fbfbbd9a0d2b1847921e6e1/lib/util.js#L262

                      variable FacebookOAuth

                      const FacebookOAuth: FacebookOAuthClass;

                        variable GoogleOAuth

                        const GoogleOAuth: GoogleOAuthClass;

                          variable Hub

                          const Hub: HubClass;

                            variable INTERNAL_AWS_APPSYNC_REALTIME_PUBSUB_PROVIDER

                            const INTERNAL_AWS_APPSYNC_REALTIME_PUBSUB_PROVIDER: string | symbol;

                              variable Linking

                              const Linking: {};

                                variable NO_CREDS_ERROR_STRING

                                const NO_CREDS_ERROR_STRING: string;

                                  variable Platform

                                  const Platform: PlatformBuilder;

                                    variable RETRY_ERROR_CODES

                                    const RETRY_ERROR_CODES: string[];

                                      variable USER_AGENT_HEADER

                                      const USER_AGENT_HEADER: string;

                                        Functions

                                        function browserOrNode

                                        browserOrNode: () => { isBrowser: boolean; isNode: boolean };

                                          function filenameToContentType

                                          filenameToContentType: (filename: any, defVal?: string) => string;

                                            function generateRandomString

                                            generateRandomString: () => string;

                                              function getAmplifyUserAgent

                                              getAmplifyUserAgent: (customUserAgentDetails?: CustomUserAgentDetails) => string;

                                                function getAmplifyUserAgentObject

                                                getAmplifyUserAgentObject: ({
                                                category,
                                                action,
                                                framework,
                                                }?: CustomUserAgentDetails) => AWSUserAgent;

                                                  function invalidParameter

                                                  invalidParameter: (name: string) => Error;

                                                    function isEmpty

                                                    isEmpty: (obj?: {}) => boolean;

                                                      function isNonRetryableError

                                                      isNonRetryableError: (obj: any) => obj is NonRetryableError;

                                                        function isStrictObject

                                                        isStrictObject: (obj: any) => boolean;
                                                        • Return true if the object is a strict object which means it's not Array, Function, Number, String, Boolean or Null

                                                          Parameter obj

                                                          the Object

                                                        function isTextFile

                                                        isTextFile: (contentType: any) => boolean;

                                                          function isWebWorker

                                                          isWebWorker: () => boolean;

                                                            function jitteredBackoff

                                                            jitteredBackoff: (maxDelayMs?: number) => DelayFunction;
                                                            • Internal use of Amplify only

                                                            function jitteredExponentialRetry

                                                            jitteredExponentialRetry: <T>(
                                                            functionToRetry: (...args: any[]) => T,
                                                            args: any[],
                                                            maxDelayMs?: number,
                                                            onTerminate?: Promise<void>
                                                            ) => Promise<T>;
                                                            • Internal use of Amplify only

                                                            function makeQuerablePromise

                                                            makeQuerablePromise: (promise: any) => any;

                                                              function missingConfig

                                                              missingConfig: (name: string) => Error;

                                                                function objectLessAttributes

                                                                objectLessAttributes: (obj: any, less: any) => any;

                                                                  function parseAWSExports

                                                                  parseAWSExports: (config: any) => AmplifyConfig;

                                                                    function retry

                                                                    retry: <T>(
                                                                    functionToRetry: (...args: any[]) => T,
                                                                    args: any[],
                                                                    delayFn: DelayFunction,
                                                                    onTerminate?: Promise<void>
                                                                    ) => Promise<T>;
                                                                    • Internal use of Amplify only

                                                                    function sortByField

                                                                    sortByField: (list: any, field: any, dir: any) => boolean;

                                                                      function transferKeyToLowerCase

                                                                      transferKeyToLowerCase: (
                                                                      obj: any,
                                                                      whiteListForItself?: any[],
                                                                      whiteListForChildren?: any[]
                                                                      ) => any;
                                                                      • transfer the first letter of the keys to lowercase

                                                                        Parameter obj

                                                                        the object need to be transferred

                                                                        Parameter whiteListForItself

                                                                        whitelist itself from being transferred

                                                                        Parameter whiteListForChildren

                                                                        whitelist its children keys from being transferred

                                                                      function transferKeyToUpperCase

                                                                      transferKeyToUpperCase: (
                                                                      obj: any,
                                                                      whiteListForItself?: any[],
                                                                      whiteListForChildren?: any[]
                                                                      ) => any;
                                                                      • transfer the first letter of the keys to lowercase

                                                                        Parameter obj

                                                                        the object need to be transferred

                                                                        Parameter whiteListForItself

                                                                        whitelist itself from being transferred

                                                                        Parameter whiteListForChildren

                                                                        whitelist its children keys from being transferred

                                                                      function urlSafeDecode

                                                                      urlSafeDecode: (hex: string) => string;

                                                                        function urlSafeEncode

                                                                        urlSafeEncode: (str: string) => string;

                                                                          Classes

                                                                          class AmplifyClass

                                                                          class AmplifyClass {}

                                                                            property Analytics

                                                                            Analytics: any;

                                                                              property API

                                                                              API: any;

                                                                                property Auth

                                                                                Auth: any;

                                                                                  property Cache

                                                                                  Cache: any;

                                                                                    property Credentials

                                                                                    Credentials: any;

                                                                                      property DataStore

                                                                                      DataStore: any;

                                                                                        property Geo

                                                                                        Geo: any;

                                                                                          property I18n

                                                                                          I18n: any;

                                                                                            property Interactions

                                                                                            Interactions: any;

                                                                                              property Logger

                                                                                              Logger: typeof LoggerClass;

                                                                                                property Notifications

                                                                                                Notifications: any;

                                                                                                  property Predictions

                                                                                                  Predictions: any;

                                                                                                    property PubSub

                                                                                                    PubSub: any;

                                                                                                      property Pushnotification

                                                                                                      Pushnotification: any;

                                                                                                        property ServiceWorker

                                                                                                        ServiceWorker: any;

                                                                                                          property Storage

                                                                                                          Storage: any;

                                                                                                            property UI

                                                                                                            UI: any;

                                                                                                              property XR

                                                                                                              XR: any;

                                                                                                                method addPluggable

                                                                                                                addPluggable: (pluggable: any) => void;

                                                                                                                  method configure

                                                                                                                  configure: (config?: any) => {};

                                                                                                                    method register

                                                                                                                    register: (comp: any) => void;

                                                                                                                      class AWSCloudWatchProvider

                                                                                                                      class AWSCloudWatchProvider implements LoggingProvider {}

                                                                                                                        constructor

                                                                                                                        constructor(config?: AWSCloudWatchProviderOptions);

                                                                                                                          property CATEGORY

                                                                                                                          static readonly CATEGORY: string;

                                                                                                                            property PROVIDER_NAME

                                                                                                                            static readonly PROVIDER_NAME: string;

                                                                                                                              method configure

                                                                                                                              configure: (
                                                                                                                              config?: AWSCloudWatchProviderOptions
                                                                                                                              ) => AWSCloudWatchProviderOptions;

                                                                                                                                method createLogGroup

                                                                                                                                createLogGroup: (
                                                                                                                                params: CreateLogGroupCommandInput
                                                                                                                                ) => Promise<CreateLogGroupCommandOutput>;

                                                                                                                                  method createLogStream

                                                                                                                                  createLogStream: (
                                                                                                                                  params: CreateLogStreamCommandInput
                                                                                                                                  ) => Promise<CreateLogStreamCommandOutput>;

                                                                                                                                    method getCategoryName

                                                                                                                                    getCategoryName: () => string;

                                                                                                                                      method getLogEvents

                                                                                                                                      getLogEvents: (
                                                                                                                                      params: GetLogEventsCommandInput
                                                                                                                                      ) => Promise<GetLogEventsCommandOutput>;

                                                                                                                                        method getLogGroups

                                                                                                                                        getLogGroups: (
                                                                                                                                        params: DescribeLogGroupsCommandInput
                                                                                                                                        ) => Promise<DescribeLogGroupsCommandOutput>;

                                                                                                                                          method getLogQueue

                                                                                                                                          getLogQueue: () => InputLogEvent[];

                                                                                                                                            method getLogStreams

                                                                                                                                            getLogStreams: (
                                                                                                                                            params: DescribeLogStreamsCommandInput
                                                                                                                                            ) => Promise<DescribeLogStreamsCommandOutput>;

                                                                                                                                              method getProviderName

                                                                                                                                              getProviderName: () => string;

                                                                                                                                                method pushLogs

                                                                                                                                                pushLogs: (logs: InputLogEvent[]) => void;

                                                                                                                                                  class BackgroundManagerNotOpenError

                                                                                                                                                  class BackgroundManagerNotOpenError extends Error {}

                                                                                                                                                  constructor

                                                                                                                                                  constructor(message: string);

                                                                                                                                                    class BackgroundProcessManager

                                                                                                                                                    class BackgroundProcessManager {}
                                                                                                                                                    • For internal Amplify use.

                                                                                                                                                      Creates a new scope for promises, observables, and other types of work or processes that may be running in the background. This manager provides an singular entrypoint to request termination and await completion.

                                                                                                                                                      As work completes on its own prior to close, the manager removes them from the registry to avoid holding references to completed jobs.

                                                                                                                                                    constructor

                                                                                                                                                    constructor();
                                                                                                                                                    • Creates a new manager for promises, observables, and other types of work that may be running in the background. This manager provides a centralized mechanism to request termination and await completion.

                                                                                                                                                    property isClosed

                                                                                                                                                    readonly isClosed: boolean;
                                                                                                                                                    • Whether the manager is rejecting work and done waiting for submitted work to complete.

                                                                                                                                                    property isClosing

                                                                                                                                                    readonly isClosing: boolean;
                                                                                                                                                    • Whether the manager is rejecting new work, but still waiting for submitted work to complete.

                                                                                                                                                    property isOpen

                                                                                                                                                    readonly isOpen: boolean;
                                                                                                                                                    • Whether the manager is accepting new jobs.

                                                                                                                                                    property length

                                                                                                                                                    readonly length: number;
                                                                                                                                                    • The number of jobs being waited on.

                                                                                                                                                      We don't use this for anything. It's just informational for the caller, and can be used in logging and testing.

                                                                                                                                                      Returns

                                                                                                                                                      the number of jobs.

                                                                                                                                                    property pending

                                                                                                                                                    readonly pending: string[];
                                                                                                                                                    • The registered description of all still-pending jobs.

                                                                                                                                                      Returns

                                                                                                                                                      descriptions as an array.

                                                                                                                                                    property state

                                                                                                                                                    readonly state: BackgroundProcessManagerState;
                                                                                                                                                    • The execution state of the manager. One of:

                                                                                                                                                      1. "Open" -> Accepting new jobs 1. "Closing" -> Not accepting new work. Waiting for jobs to complete. 1. "Closed" -> Not accepting new work. All submitted jobs are complete.

                                                                                                                                                    method add

                                                                                                                                                    add: {
                                                                                                                                                    <T>(job: () => Promise<T>, description?: string): Promise<T>;
                                                                                                                                                    <T>(
                                                                                                                                                    job: (onTerminate: Promise<void>) => Promise<T>,
                                                                                                                                                    description?: string
                                                                                                                                                    ): Promise<T>;
                                                                                                                                                    (description?: string): {
                                                                                                                                                    resolve: (value?: unknown) => void;
                                                                                                                                                    reject: (reason?: any) => void;
                                                                                                                                                    onTerminate: Promise<void>;
                                                                                                                                                    };
                                                                                                                                                    (job: BackgroundProcessManager, description?: string): any;
                                                                                                                                                    };
                                                                                                                                                    • Executes an async job function, passing the return value through to the caller, registering it as a running job in the manager. When the manager *closes*, it will await the job.

                                                                                                                                                      Parameter job

                                                                                                                                                      The function to execute.

                                                                                                                                                      Parameter description

                                                                                                                                                      Optional description to help identify pending jobs.

                                                                                                                                                      Returns

                                                                                                                                                      The return value from the given function.

                                                                                                                                                    • Executes an async job function, passing the return value through to the caller, registering it as a running job in the manager. When the manager *closes*, it will request termination by resolving the provided onTerminate promise. It will then await the job, so it is important that the job still resolve() or reject() when responding to a termination request.

                                                                                                                                                      Parameter job

                                                                                                                                                      The function to execute.

                                                                                                                                                      Parameter description

                                                                                                                                                      Optional description to help identify pending jobs.

                                                                                                                                                      Returns

                                                                                                                                                      The return value from the given function.

                                                                                                                                                    • Create a no-op job, registers it with the manager, and returns hooks to the caller to signal the job's completion and respond to termination requests.

                                                                                                                                                      When the manager closes, the no-op job will be await-ed, so its important to always resolve() or reject() when done responding to an onTerminate signal.

                                                                                                                                                      Parameter description

                                                                                                                                                      Optional description to help identify pending jobs.

                                                                                                                                                      Returns

                                                                                                                                                      Job promise hooks + onTerminate signaling promise

                                                                                                                                                    • Adds another job manager to await on at the time of closing. the inner manager's termination is signaled when this manager's close() is called for.

                                                                                                                                                      Parameter job

                                                                                                                                                      The inner job manager to await.

                                                                                                                                                      Parameter description

                                                                                                                                                      Optional description to help identify pending jobs.

                                                                                                                                                    method addCleaner

                                                                                                                                                    addCleaner: <T>(
                                                                                                                                                    clean: () => Promise<T>,
                                                                                                                                                    description?: string
                                                                                                                                                    ) => () => Promise<void>;
                                                                                                                                                    • Adds a **cleaner** function that doesn't immediately get executed. Instead, the caller gets a **terminate** function back. The *cleaner* is invoked only once the mananger *closes* or the returned **terminate** function is called.

                                                                                                                                                      Parameter clean

                                                                                                                                                      The cleanup function.

                                                                                                                                                      Parameter description

                                                                                                                                                      Optional description to help identify pending jobs.

                                                                                                                                                      Returns

                                                                                                                                                      A terminate function.

                                                                                                                                                    method close

                                                                                                                                                    close: () => Promise<any>;
                                                                                                                                                    • Signals jobs to stop (for those that accept interruptions) and waits for confirmation that jobs have stopped.

                                                                                                                                                      This immediately puts the manager into a closing state and just begins to reject new work. After all work in the manager is complete, the manager goes into a Completed state and close() returns.

                                                                                                                                                      This call is idempotent.

                                                                                                                                                      If the manager is already closing or closed, finalCleaup is not executed.

                                                                                                                                                      Parameter onClosed

                                                                                                                                                      Returns

                                                                                                                                                      The settled results of each still-running job's promise. If the manager is already closed, this will contain the results as of when the manager's close() was called in an Open state.

                                                                                                                                                    method open

                                                                                                                                                    open: () => Promise<void>;
                                                                                                                                                    • Signals the manager to start accepting work (again) and returns once the manager is ready to do so.

                                                                                                                                                      If the state is already Open, this call is a no-op.

                                                                                                                                                      If the state is Closed, this call simply updates state and returns.

                                                                                                                                                      If the state is Closing, this call waits for completion before it updates the state and returns.

                                                                                                                                                    class ClientDevice

                                                                                                                                                    class ClientDevice {}

                                                                                                                                                      method clientInfo

                                                                                                                                                      static clientInfo: () =>
                                                                                                                                                      | {
                                                                                                                                                      platform?: undefined;
                                                                                                                                                      make?: undefined;
                                                                                                                                                      model?: undefined;
                                                                                                                                                      version?: undefined;
                                                                                                                                                      appVersion?: undefined;
                                                                                                                                                      language?: undefined;
                                                                                                                                                      timezone?: undefined;
                                                                                                                                                      }
                                                                                                                                                      | {
                                                                                                                                                      platform: string;
                                                                                                                                                      make: string;
                                                                                                                                                      model: string;
                                                                                                                                                      version: string;
                                                                                                                                                      appVersion: string;
                                                                                                                                                      language: string;
                                                                                                                                                      timezone: string;
                                                                                                                                                      };

                                                                                                                                                        method dimension

                                                                                                                                                        static dimension: () => { width: number; height: number };

                                                                                                                                                          class ConsoleLogger

                                                                                                                                                          class ConsoleLogger implements Logger {}
                                                                                                                                                          • Write logs Logger

                                                                                                                                                          constructor

                                                                                                                                                          constructor(name: string, level?: string);
                                                                                                                                                          • Parameter name

                                                                                                                                                            Name of the logger

                                                                                                                                                          property level

                                                                                                                                                          level: string;

                                                                                                                                                            property LOG_LEVEL

                                                                                                                                                            static LOG_LEVEL: any;

                                                                                                                                                              property name

                                                                                                                                                              name: string;

                                                                                                                                                                method addPluggable

                                                                                                                                                                addPluggable: (pluggable: LoggingProvider) => void;

                                                                                                                                                                  method configure

                                                                                                                                                                  configure: (config?: object) => object;

                                                                                                                                                                    method debug

                                                                                                                                                                    debug: (...msg: any[]) => void;
                                                                                                                                                                    • Write DEBUG log Logger

                                                                                                                                                                      Parameter msg

                                                                                                                                                                      Logging message or object

                                                                                                                                                                    method error

                                                                                                                                                                    error: (...msg: any[]) => void;
                                                                                                                                                                    • Write ERROR log Logger

                                                                                                                                                                      Parameter msg

                                                                                                                                                                      Logging message or object

                                                                                                                                                                    method info

                                                                                                                                                                    info: (...msg: any[]) => void;
                                                                                                                                                                    • Write INFO log Logger

                                                                                                                                                                      Parameter msg

                                                                                                                                                                      Logging message or object

                                                                                                                                                                    method listPluggables

                                                                                                                                                                    listPluggables: () => LoggingProvider[];

                                                                                                                                                                      method log

                                                                                                                                                                      log: (...msg: any[]) => void;
                                                                                                                                                                      • Write General log. Default to INFO Logger

                                                                                                                                                                        Parameter msg

                                                                                                                                                                        Logging message or object

                                                                                                                                                                      method verbose

                                                                                                                                                                      verbose: (...msg: any[]) => void;
                                                                                                                                                                      • Write VERBOSE log Logger

                                                                                                                                                                        Parameter msg

                                                                                                                                                                        Logging message or object

                                                                                                                                                                      method warn

                                                                                                                                                                      warn: (...msg: any[]) => void;
                                                                                                                                                                      • Write WARN log Logger

                                                                                                                                                                        Parameter msg

                                                                                                                                                                        Logging message or object

                                                                                                                                                                      class CredentialsClass

                                                                                                                                                                      class CredentialsClass {}

                                                                                                                                                                        constructor

                                                                                                                                                                        constructor(config: any);

                                                                                                                                                                          property Auth

                                                                                                                                                                          Auth: any;

                                                                                                                                                                            method clear

                                                                                                                                                                            clear: () => Promise<void>;

                                                                                                                                                                              method configure

                                                                                                                                                                              configure: (config: any) => any;

                                                                                                                                                                                method get

                                                                                                                                                                                get: () => any;

                                                                                                                                                                                  method getCredSource

                                                                                                                                                                                  getCredSource: () => any;

                                                                                                                                                                                    method getModuleName

                                                                                                                                                                                    getModuleName: () => string;

                                                                                                                                                                                      method refreshFederatedToken

                                                                                                                                                                                      refreshFederatedToken: (federatedInfo: any) => Promise<ICredentials>;

                                                                                                                                                                                        method set

                                                                                                                                                                                        set: (params: any, source: any) => Promise<ICredentials>;

                                                                                                                                                                                          method shear

                                                                                                                                                                                          shear: (credentials: any) => {
                                                                                                                                                                                          accessKeyId: any;
                                                                                                                                                                                          sessionToken: any;
                                                                                                                                                                                          secretAccessKey: any;
                                                                                                                                                                                          identityId: any;
                                                                                                                                                                                          authenticated: any;
                                                                                                                                                                                          };
                                                                                                                                                                                          • Compact version of credentials

                                                                                                                                                                                            Parameter credentials

                                                                                                                                                                                            {Object} - Credentials

                                                                                                                                                                                          class I18n

                                                                                                                                                                                          class I18n {}
                                                                                                                                                                                          • Export I18n APIs

                                                                                                                                                                                          method checkConfig

                                                                                                                                                                                          static checkConfig: () => boolean;

                                                                                                                                                                                            method configure

                                                                                                                                                                                            static configure: (config: any) => any;
                                                                                                                                                                                            • Configure I18n part

                                                                                                                                                                                              Parameter config

                                                                                                                                                                                              Configuration of the I18n

                                                                                                                                                                                            method createInstance

                                                                                                                                                                                            static createInstance: () => void;
                                                                                                                                                                                            • Create an instance of I18n for the library

                                                                                                                                                                                            method get

                                                                                                                                                                                            static get: (key: any, defVal?: any) => any;
                                                                                                                                                                                            • Get value

                                                                                                                                                                                              Parameter key

                                                                                                                                                                                              Parameter defVal

                                                                                                                                                                                              Default value

                                                                                                                                                                                            method getModuleName

                                                                                                                                                                                            static getModuleName: () => string;

                                                                                                                                                                                              method putVocabularies

                                                                                                                                                                                              static putVocabularies: (vocabularies: any) => any;
                                                                                                                                                                                              • Add vocabularies for one language

                                                                                                                                                                                                Parameter vocabularies

                                                                                                                                                                                                Object that has language as key, vocabularies of each language as value

                                                                                                                                                                                              method putVocabulariesForLanguage

                                                                                                                                                                                              static putVocabulariesForLanguage: (language: any, vocabularies: any) => any;
                                                                                                                                                                                              • Add vocabularies for one language

                                                                                                                                                                                                Parameter langurage

                                                                                                                                                                                                Language of the dictionary

                                                                                                                                                                                                Parameter vocabularies

                                                                                                                                                                                                Object that has key-value as dictionary entry

                                                                                                                                                                                              method setLanguage

                                                                                                                                                                                              static setLanguage: (lang: any) => any;
                                                                                                                                                                                              • Explicitly setting language

                                                                                                                                                                                                Parameter lang

                                                                                                                                                                                              class Logger

                                                                                                                                                                                              class ConsoleLogger implements Logger {}
                                                                                                                                                                                              • Write logs Logger

                                                                                                                                                                                              constructor

                                                                                                                                                                                              constructor(name: string, level?: string);
                                                                                                                                                                                              • Parameter name

                                                                                                                                                                                                Name of the logger

                                                                                                                                                                                              property level

                                                                                                                                                                                              level: string;

                                                                                                                                                                                                property LOG_LEVEL

                                                                                                                                                                                                static LOG_LEVEL: any;

                                                                                                                                                                                                  property name

                                                                                                                                                                                                  name: string;

                                                                                                                                                                                                    method addPluggable

                                                                                                                                                                                                    addPluggable: (pluggable: LoggingProvider) => void;

                                                                                                                                                                                                      method configure

                                                                                                                                                                                                      configure: (config?: object) => object;

                                                                                                                                                                                                        method debug

                                                                                                                                                                                                        debug: (...msg: any[]) => void;
                                                                                                                                                                                                        • Write DEBUG log Logger

                                                                                                                                                                                                          Parameter msg

                                                                                                                                                                                                          Logging message or object

                                                                                                                                                                                                        method error

                                                                                                                                                                                                        error: (...msg: any[]) => void;
                                                                                                                                                                                                        • Write ERROR log Logger

                                                                                                                                                                                                          Parameter msg

                                                                                                                                                                                                          Logging message or object

                                                                                                                                                                                                        method info

                                                                                                                                                                                                        info: (...msg: any[]) => void;
                                                                                                                                                                                                        • Write INFO log Logger

                                                                                                                                                                                                          Parameter msg

                                                                                                                                                                                                          Logging message or object

                                                                                                                                                                                                        method listPluggables

                                                                                                                                                                                                        listPluggables: () => LoggingProvider[];

                                                                                                                                                                                                          method log

                                                                                                                                                                                                          log: (...msg: any[]) => void;
                                                                                                                                                                                                          • Write General log. Default to INFO Logger

                                                                                                                                                                                                            Parameter msg

                                                                                                                                                                                                            Logging message or object

                                                                                                                                                                                                          method verbose

                                                                                                                                                                                                          verbose: (...msg: any[]) => void;
                                                                                                                                                                                                          • Write VERBOSE log Logger

                                                                                                                                                                                                            Parameter msg

                                                                                                                                                                                                            Logging message or object

                                                                                                                                                                                                          method warn

                                                                                                                                                                                                          warn: (...msg: any[]) => void;
                                                                                                                                                                                                          • Write WARN log Logger

                                                                                                                                                                                                            Parameter msg

                                                                                                                                                                                                            Logging message or object

                                                                                                                                                                                                          class MemoryStorage

                                                                                                                                                                                                          class MemoryStorage {}

                                                                                                                                                                                                          method clear

                                                                                                                                                                                                          static clear: () => {};
                                                                                                                                                                                                          • This is used to clear the storage

                                                                                                                                                                                                            Returns

                                                                                                                                                                                                            {string} nothing

                                                                                                                                                                                                          method getItem

                                                                                                                                                                                                          static getItem: (key: string) => any;
                                                                                                                                                                                                          • This is used to get a specific key from storage

                                                                                                                                                                                                            Parameter key

                                                                                                                                                                                                            the key for the item This is used to clear the storage

                                                                                                                                                                                                            Returns

                                                                                                                                                                                                            {string} the data item

                                                                                                                                                                                                          method removeItem

                                                                                                                                                                                                          static removeItem: (key: string) => boolean;
                                                                                                                                                                                                          • This is used to remove an item from storage

                                                                                                                                                                                                            Parameter key

                                                                                                                                                                                                            the key being set

                                                                                                                                                                                                            Returns

                                                                                                                                                                                                            {string} value - value that was deleted

                                                                                                                                                                                                          method setItem

                                                                                                                                                                                                          static setItem: (key: string, value: any) => any;
                                                                                                                                                                                                          • This is used to set a specific item in storage

                                                                                                                                                                                                            Parameter key

                                                                                                                                                                                                            the key for the item

                                                                                                                                                                                                            Parameter value

                                                                                                                                                                                                            the value

                                                                                                                                                                                                            Returns

                                                                                                                                                                                                            {string} value that was set

                                                                                                                                                                                                          class Mutex

                                                                                                                                                                                                          class Mutex implements MutexInterface {}

                                                                                                                                                                                                            method acquire

                                                                                                                                                                                                            acquire: () => Promise<MutexInterface.Releaser>;

                                                                                                                                                                                                              method isLocked

                                                                                                                                                                                                              isLocked: () => boolean;

                                                                                                                                                                                                                method runExclusive

                                                                                                                                                                                                                runExclusive: <T>(callback: MutexInterface.Worker<T>) => Promise<T>;

                                                                                                                                                                                                                  class NonRetryableError

                                                                                                                                                                                                                  class NonRetryableError extends Error {}

                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                    constructor(message: string);

                                                                                                                                                                                                                      property nonRetryable

                                                                                                                                                                                                                      readonly nonRetryable: boolean;

                                                                                                                                                                                                                        class Reachability

                                                                                                                                                                                                                        class ReachabilityNavigator implements Reachability {}

                                                                                                                                                                                                                          method networkMonitor

                                                                                                                                                                                                                          networkMonitor: (netInfo?: any) => Observable<NetworkStatus>;

                                                                                                                                                                                                                            class ServiceWorker

                                                                                                                                                                                                                            class ServiceWorkerClass {}
                                                                                                                                                                                                                            • Provides a means to registering a service worker in the browser and communicating with it via postMessage events. https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API/

                                                                                                                                                                                                                              postMessage events are currently not supported in all browsers. See: https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API

                                                                                                                                                                                                                              At the minmum this class will register the service worker and listen and attempt to dispatch messages on state change and record analytics events based on the service worker lifecycle.

                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                            constructor();

                                                                                                                                                                                                                              property serviceWorker

                                                                                                                                                                                                                              readonly serviceWorker: ServiceWorker;
                                                                                                                                                                                                                              • Get the currently active service worker

                                                                                                                                                                                                                              method enablePush

                                                                                                                                                                                                                              enablePush: (publicKey: string) => Promise<unknown>;
                                                                                                                                                                                                                              • Enable web push notifications. If not subscribed, a new subscription will be created and registered. Test Push Server: https://web-push-codelab.glitch.me/ Push Server Libraries: https://github.com/web-push-libs/ API Doc: https://developers.google.com/web/fundamentals/codelabs/push-notifications/

                                                                                                                                                                                                                                Parameter publicKey

                                                                                                                                                                                                                                Returns

                                                                                                                                                                                                                                {Promise} - resolve(PushSubscription) - reject(Error)

                                                                                                                                                                                                                              method register

                                                                                                                                                                                                                              register: (filePath?: string, scope?: string) => Promise<unknown>;
                                                                                                                                                                                                                              • Register the service-worker.js file in the browser Make sure the service-worker.js is part of the build for example with Angular, modify the angular-cli.json file and add to "assets" array "service-worker.js"

                                                                                                                                                                                                                                Parameter

                                                                                                                                                                                                                                {string} - (optional) Service worker file. Defaults to "/service-worker.js"

                                                                                                                                                                                                                                Parameter

                                                                                                                                                                                                                                {string} - (optional) The service worker scope. Defaults to "/" - API Doc: https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/register

                                                                                                                                                                                                                                Returns

                                                                                                                                                                                                                                {Promise} - resolve(ServiceWorkerRegistration) - reject(Error)

                                                                                                                                                                                                                              method send

                                                                                                                                                                                                                              send: (message: object | string) => void;
                                                                                                                                                                                                                              • Send a message to the service worker. The service worker needs to implement `self.addEventListener('message') to handle the message. This ***currently*** does not work in Safari or IE.

                                                                                                                                                                                                                                Parameter

                                                                                                                                                                                                                                {object | string} - An arbitrary JSON object or string message to send to the service worker - see: https://developer.mozilla.org/en-US/docs/Web/API/Transferable

                                                                                                                                                                                                                                Returns

                                                                                                                                                                                                                                {Promise}

                                                                                                                                                                                                                              class Signer

                                                                                                                                                                                                                              class Signer {}

                                                                                                                                                                                                                                method sign

                                                                                                                                                                                                                                static sign: (request: any, accessInfo: any, serviceInfo: any) => any;
                                                                                                                                                                                                                                • Sign a HTTP request, add 'Authorization' header to request param sign Signer

                                                                                                                                                                                                                                  Parameter request

                                                                                                                                                                                                                                  HTTP request object request: { method: GET | POST | PUT ... url: ..., headers: { header1: ... }, data: data }

                                                                                                                                                                                                                                  Parameter access_info

                                                                                                                                                                                                                                  AWS access credential info access_info: { access_key: ..., secret_key: ..., session_token: ... }

                                                                                                                                                                                                                                  Parameter service_info

                                                                                                                                                                                                                                  AWS service type and region, optional, if not provided then parse out from url service_info: { service: ..., region: ... }

                                                                                                                                                                                                                                  Returns

                                                                                                                                                                                                                                  {object} Signed HTTP request

                                                                                                                                                                                                                                method signUrl

                                                                                                                                                                                                                                static signUrl: {
                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                urlToSign: string,
                                                                                                                                                                                                                                accessInfo: any,
                                                                                                                                                                                                                                serviceInfo?: any,
                                                                                                                                                                                                                                expiration?: number
                                                                                                                                                                                                                                ): string;
                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                request: any,
                                                                                                                                                                                                                                accessInfo: any,
                                                                                                                                                                                                                                serviceInfo?: any,
                                                                                                                                                                                                                                expiration?: number
                                                                                                                                                                                                                                ): string;
                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                  class StorageHelper

                                                                                                                                                                                                                                  class StorageHelper {}

                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                    constructor();
                                                                                                                                                                                                                                    • This is used to get a storage object

                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                      {object} the storage

                                                                                                                                                                                                                                    method getStorage

                                                                                                                                                                                                                                    getStorage: () => any;
                                                                                                                                                                                                                                    • This is used to return the storage

                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                      {object} the storage

                                                                                                                                                                                                                                    class UniversalStorage

                                                                                                                                                                                                                                    class UniversalStorage implements Storage {}

                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                      constructor(context?: Context);

                                                                                                                                                                                                                                        property cookies

                                                                                                                                                                                                                                        cookies: Cookies;

                                                                                                                                                                                                                                          property length

                                                                                                                                                                                                                                          readonly length: number;

                                                                                                                                                                                                                                            property store

                                                                                                                                                                                                                                            store: Store;

                                                                                                                                                                                                                                              method clear

                                                                                                                                                                                                                                              clear: () => void;

                                                                                                                                                                                                                                                method getItem

                                                                                                                                                                                                                                                getItem: (key: keyof Store) => string;

                                                                                                                                                                                                                                                  method getLocalItem

                                                                                                                                                                                                                                                  protected getLocalItem: (key: keyof Store) => string;

                                                                                                                                                                                                                                                    method getUniversalItem

                                                                                                                                                                                                                                                    protected getUniversalItem: (key: keyof Store) => any;

                                                                                                                                                                                                                                                      method key

                                                                                                                                                                                                                                                      key: (index: number) => string;

                                                                                                                                                                                                                                                        method removeItem

                                                                                                                                                                                                                                                        removeItem: (key: string) => void;

                                                                                                                                                                                                                                                          method removeLocalItem

                                                                                                                                                                                                                                                          protected removeLocalItem: (key: keyof Store) => void;

                                                                                                                                                                                                                                                            method removeUniversalItem

                                                                                                                                                                                                                                                            protected removeUniversalItem: (key: keyof Store) => void;

                                                                                                                                                                                                                                                              method setItem

                                                                                                                                                                                                                                                              setItem: (key: keyof Store, value: string) => void;

                                                                                                                                                                                                                                                                method setLocalItem

                                                                                                                                                                                                                                                                protected setLocalItem: (key: keyof Store, value: string) => void;

                                                                                                                                                                                                                                                                  method setUniversalItem

                                                                                                                                                                                                                                                                  protected setUniversalItem: (
                                                                                                                                                                                                                                                                  key: keyof Store,
                                                                                                                                                                                                                                                                  value: string,
                                                                                                                                                                                                                                                                  options?: CookieSetOptions
                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                    Interfaces

                                                                                                                                                                                                                                                                    interface ICredentials

                                                                                                                                                                                                                                                                    interface ICredentials {}

                                                                                                                                                                                                                                                                      property accessKeyId

                                                                                                                                                                                                                                                                      accessKeyId: string;

                                                                                                                                                                                                                                                                        property authenticated

                                                                                                                                                                                                                                                                        authenticated: boolean;

                                                                                                                                                                                                                                                                          property expiration

                                                                                                                                                                                                                                                                          expiration?: Date;

                                                                                                                                                                                                                                                                            property identityId

                                                                                                                                                                                                                                                                            identityId: string;

                                                                                                                                                                                                                                                                              property secretAccessKey

                                                                                                                                                                                                                                                                              secretAccessKey: string;

                                                                                                                                                                                                                                                                                property sessionToken

                                                                                                                                                                                                                                                                                sessionToken: string;

                                                                                                                                                                                                                                                                                  Enums

                                                                                                                                                                                                                                                                                  enum AnalyticsAction

                                                                                                                                                                                                                                                                                  enum AnalyticsAction {
                                                                                                                                                                                                                                                                                  Record = '1',
                                                                                                                                                                                                                                                                                  UpdateEndpoint = '2',
                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                    member Record

                                                                                                                                                                                                                                                                                    Record = '1'

                                                                                                                                                                                                                                                                                      member UpdateEndpoint

                                                                                                                                                                                                                                                                                      UpdateEndpoint = '2'

                                                                                                                                                                                                                                                                                        enum ApiAction

                                                                                                                                                                                                                                                                                        enum ApiAction {
                                                                                                                                                                                                                                                                                        GraphQl = '1',
                                                                                                                                                                                                                                                                                        Get = '2',
                                                                                                                                                                                                                                                                                        Post = '3',
                                                                                                                                                                                                                                                                                        Put = '4',
                                                                                                                                                                                                                                                                                        Patch = '5',
                                                                                                                                                                                                                                                                                        Del = '6',
                                                                                                                                                                                                                                                                                        Head = '7',
                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                          member Del

                                                                                                                                                                                                                                                                                          Del = '6'

                                                                                                                                                                                                                                                                                            member Get

                                                                                                                                                                                                                                                                                            Get = '2'

                                                                                                                                                                                                                                                                                              member GraphQl

                                                                                                                                                                                                                                                                                              GraphQl = '1'

                                                                                                                                                                                                                                                                                                member Head

                                                                                                                                                                                                                                                                                                Head = '7'

                                                                                                                                                                                                                                                                                                  member Patch

                                                                                                                                                                                                                                                                                                  Patch = '5'

                                                                                                                                                                                                                                                                                                    member Post

                                                                                                                                                                                                                                                                                                    Post = '3'

                                                                                                                                                                                                                                                                                                      member Put

                                                                                                                                                                                                                                                                                                      Put = '4'

                                                                                                                                                                                                                                                                                                        enum AuthAction

                                                                                                                                                                                                                                                                                                        enum AuthAction {
                                                                                                                                                                                                                                                                                                        FederatedSignIn = '30',
                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                          member FederatedSignIn

                                                                                                                                                                                                                                                                                                          FederatedSignIn = '30'

                                                                                                                                                                                                                                                                                                            enum BackgroundProcessManagerState

                                                                                                                                                                                                                                                                                                            enum BackgroundProcessManagerState {
                                                                                                                                                                                                                                                                                                            Open = 'Open',
                                                                                                                                                                                                                                                                                                            Closing = 'Closing',
                                                                                                                                                                                                                                                                                                            Closed = 'Closed',
                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                            • All possible states a BackgroundProcessManager instance can be in.

                                                                                                                                                                                                                                                                                                            member Closed

                                                                                                                                                                                                                                                                                                            Closed = 'Closed'
                                                                                                                                                                                                                                                                                                            • Not accepting new jobs. All submitted jobs are complete.

                                                                                                                                                                                                                                                                                                            member Closing

                                                                                                                                                                                                                                                                                                            Closing = 'Closing'
                                                                                                                                                                                                                                                                                                            • Not accepting new jobs. Waiting for submitted jobs to complete.

                                                                                                                                                                                                                                                                                                            member Open

                                                                                                                                                                                                                                                                                                            Open = 'Open'
                                                                                                                                                                                                                                                                                                            • Accepting new jobs.

                                                                                                                                                                                                                                                                                                            enum Category

                                                                                                                                                                                                                                                                                                            enum Category {
                                                                                                                                                                                                                                                                                                            API = 'api',
                                                                                                                                                                                                                                                                                                            Auth = 'auth',
                                                                                                                                                                                                                                                                                                            Analytics = 'analytics',
                                                                                                                                                                                                                                                                                                            DataStore = 'datastore',
                                                                                                                                                                                                                                                                                                            Geo = 'geo',
                                                                                                                                                                                                                                                                                                            InAppMessaging = 'inappmessaging',
                                                                                                                                                                                                                                                                                                            Interactions = 'interactions',
                                                                                                                                                                                                                                                                                                            Predictions = 'predictions',
                                                                                                                                                                                                                                                                                                            PubSub = 'pubsub',
                                                                                                                                                                                                                                                                                                            PushNotification = 'pushnotification',
                                                                                                                                                                                                                                                                                                            Storage = 'storage',
                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                              member Analytics

                                                                                                                                                                                                                                                                                                              Analytics = 'analytics'

                                                                                                                                                                                                                                                                                                                member API

                                                                                                                                                                                                                                                                                                                API = 'api'

                                                                                                                                                                                                                                                                                                                  member Auth

                                                                                                                                                                                                                                                                                                                  Auth = 'auth'

                                                                                                                                                                                                                                                                                                                    member DataStore

                                                                                                                                                                                                                                                                                                                    DataStore = 'datastore'

                                                                                                                                                                                                                                                                                                                      member Geo

                                                                                                                                                                                                                                                                                                                      Geo = 'geo'

                                                                                                                                                                                                                                                                                                                        member InAppMessaging

                                                                                                                                                                                                                                                                                                                        InAppMessaging = 'inappmessaging'

                                                                                                                                                                                                                                                                                                                          member Interactions

                                                                                                                                                                                                                                                                                                                          Interactions = 'interactions'

                                                                                                                                                                                                                                                                                                                            member Predictions

                                                                                                                                                                                                                                                                                                                            Predictions = 'predictions'

                                                                                                                                                                                                                                                                                                                              member PubSub

                                                                                                                                                                                                                                                                                                                              PubSub = 'pubsub'

                                                                                                                                                                                                                                                                                                                                member PushNotification

                                                                                                                                                                                                                                                                                                                                PushNotification = 'pushnotification'

                                                                                                                                                                                                                                                                                                                                  member Storage

                                                                                                                                                                                                                                                                                                                                  Storage = 'storage'

                                                                                                                                                                                                                                                                                                                                    enum DataStoreAction

                                                                                                                                                                                                                                                                                                                                    enum DataStoreAction {
                                                                                                                                                                                                                                                                                                                                    Subscribe = '1',
                                                                                                                                                                                                                                                                                                                                    GraphQl = '2',
                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                      member GraphQl

                                                                                                                                                                                                                                                                                                                                      GraphQl = '2'

                                                                                                                                                                                                                                                                                                                                        member Subscribe

                                                                                                                                                                                                                                                                                                                                        Subscribe = '1'

                                                                                                                                                                                                                                                                                                                                          enum Framework

                                                                                                                                                                                                                                                                                                                                          enum Framework {
                                                                                                                                                                                                                                                                                                                                          WebUnknown = '0',
                                                                                                                                                                                                                                                                                                                                          React = '1',
                                                                                                                                                                                                                                                                                                                                          NextJs = '2',
                                                                                                                                                                                                                                                                                                                                          Angular = '3',
                                                                                                                                                                                                                                                                                                                                          VueJs = '4',
                                                                                                                                                                                                                                                                                                                                          Nuxt = '5',
                                                                                                                                                                                                                                                                                                                                          Svelte = '6',
                                                                                                                                                                                                                                                                                                                                          ServerSideUnknown = '100',
                                                                                                                                                                                                                                                                                                                                          ReactSSR = '101',
                                                                                                                                                                                                                                                                                                                                          NextJsSSR = '102',
                                                                                                                                                                                                                                                                                                                                          AngularSSR = '103',
                                                                                                                                                                                                                                                                                                                                          VueJsSSR = '104',
                                                                                                                                                                                                                                                                                                                                          NuxtSSR = '105',
                                                                                                                                                                                                                                                                                                                                          SvelteSSR = '106',
                                                                                                                                                                                                                                                                                                                                          ReactNative = '201',
                                                                                                                                                                                                                                                                                                                                          Expo = '202',
                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                            member Angular

                                                                                                                                                                                                                                                                                                                                            Angular = '3'

                                                                                                                                                                                                                                                                                                                                              member AngularSSR

                                                                                                                                                                                                                                                                                                                                              AngularSSR = '103'

                                                                                                                                                                                                                                                                                                                                                member Expo

                                                                                                                                                                                                                                                                                                                                                Expo = '202'

                                                                                                                                                                                                                                                                                                                                                  member NextJs

                                                                                                                                                                                                                                                                                                                                                  NextJs = '2'

                                                                                                                                                                                                                                                                                                                                                    member NextJsSSR

                                                                                                                                                                                                                                                                                                                                                    NextJsSSR = '102'

                                                                                                                                                                                                                                                                                                                                                      member Nuxt

                                                                                                                                                                                                                                                                                                                                                      Nuxt = '5'

                                                                                                                                                                                                                                                                                                                                                        member NuxtSSR

                                                                                                                                                                                                                                                                                                                                                        NuxtSSR = '105'

                                                                                                                                                                                                                                                                                                                                                          member React

                                                                                                                                                                                                                                                                                                                                                          React = '1'

                                                                                                                                                                                                                                                                                                                                                            member ReactNative

                                                                                                                                                                                                                                                                                                                                                            ReactNative = '201'

                                                                                                                                                                                                                                                                                                                                                              member ReactSSR

                                                                                                                                                                                                                                                                                                                                                              ReactSSR = '101'

                                                                                                                                                                                                                                                                                                                                                                member ServerSideUnknown

                                                                                                                                                                                                                                                                                                                                                                ServerSideUnknown = '100'

                                                                                                                                                                                                                                                                                                                                                                  member Svelte

                                                                                                                                                                                                                                                                                                                                                                  Svelte = '6'

                                                                                                                                                                                                                                                                                                                                                                    member SvelteSSR

                                                                                                                                                                                                                                                                                                                                                                    SvelteSSR = '106'

                                                                                                                                                                                                                                                                                                                                                                      member VueJs

                                                                                                                                                                                                                                                                                                                                                                      VueJs = '4'

                                                                                                                                                                                                                                                                                                                                                                        member VueJsSSR

                                                                                                                                                                                                                                                                                                                                                                        VueJsSSR = '104'

                                                                                                                                                                                                                                                                                                                                                                          member WebUnknown

                                                                                                                                                                                                                                                                                                                                                                          WebUnknown = '0'

                                                                                                                                                                                                                                                                                                                                                                            enum GeoAction

                                                                                                                                                                                                                                                                                                                                                                            enum GeoAction {
                                                                                                                                                                                                                                                                                                                                                                            None = '0',
                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                              member None

                                                                                                                                                                                                                                                                                                                                                                              None = '0'

                                                                                                                                                                                                                                                                                                                                                                                enum InAppMessagingAction

                                                                                                                                                                                                                                                                                                                                                                                enum InAppMessagingAction {
                                                                                                                                                                                                                                                                                                                                                                                None = '0',
                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                  member None

                                                                                                                                                                                                                                                                                                                                                                                  None = '0'

                                                                                                                                                                                                                                                                                                                                                                                    enum InteractionsAction

                                                                                                                                                                                                                                                                                                                                                                                    enum InteractionsAction {
                                                                                                                                                                                                                                                                                                                                                                                    None = '0',
                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                      member None

                                                                                                                                                                                                                                                                                                                                                                                      None = '0'

                                                                                                                                                                                                                                                                                                                                                                                        enum PredictionsAction

                                                                                                                                                                                                                                                                                                                                                                                        enum PredictionsAction {
                                                                                                                                                                                                                                                                                                                                                                                        Convert = '1',
                                                                                                                                                                                                                                                                                                                                                                                        Identify = '2',
                                                                                                                                                                                                                                                                                                                                                                                        Interpret = '3',
                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                          member Convert

                                                                                                                                                                                                                                                                                                                                                                                          Convert = '1'

                                                                                                                                                                                                                                                                                                                                                                                            member Identify

                                                                                                                                                                                                                                                                                                                                                                                            Identify = '2'

                                                                                                                                                                                                                                                                                                                                                                                              member Interpret

                                                                                                                                                                                                                                                                                                                                                                                              Interpret = '3'

                                                                                                                                                                                                                                                                                                                                                                                                enum PubSubAction

                                                                                                                                                                                                                                                                                                                                                                                                enum PubSubAction {
                                                                                                                                                                                                                                                                                                                                                                                                Subscribe = '1',
                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                  member Subscribe

                                                                                                                                                                                                                                                                                                                                                                                                  Subscribe = '1'

                                                                                                                                                                                                                                                                                                                                                                                                    enum PushNotificationAction

                                                                                                                                                                                                                                                                                                                                                                                                    enum PushNotificationAction {
                                                                                                                                                                                                                                                                                                                                                                                                    None = '0',
                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                      member None

                                                                                                                                                                                                                                                                                                                                                                                                      None = '0'

                                                                                                                                                                                                                                                                                                                                                                                                        enum StorageAction

                                                                                                                                                                                                                                                                                                                                                                                                        enum StorageAction {
                                                                                                                                                                                                                                                                                                                                                                                                        Put = '1',
                                                                                                                                                                                                                                                                                                                                                                                                        Get = '2',
                                                                                                                                                                                                                                                                                                                                                                                                        List = '3',
                                                                                                                                                                                                                                                                                                                                                                                                        Copy = '4',
                                                                                                                                                                                                                                                                                                                                                                                                        Remove = '5',
                                                                                                                                                                                                                                                                                                                                                                                                        GetProperties = '6',
                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                          member Copy

                                                                                                                                                                                                                                                                                                                                                                                                          Copy = '4'

                                                                                                                                                                                                                                                                                                                                                                                                            member Get

                                                                                                                                                                                                                                                                                                                                                                                                            Get = '2'

                                                                                                                                                                                                                                                                                                                                                                                                              member GetProperties

                                                                                                                                                                                                                                                                                                                                                                                                              GetProperties = '6'

                                                                                                                                                                                                                                                                                                                                                                                                                member List

                                                                                                                                                                                                                                                                                                                                                                                                                List = '3'

                                                                                                                                                                                                                                                                                                                                                                                                                  member Put

                                                                                                                                                                                                                                                                                                                                                                                                                  Put = '1'

                                                                                                                                                                                                                                                                                                                                                                                                                    member Remove

                                                                                                                                                                                                                                                                                                                                                                                                                    Remove = '5'

                                                                                                                                                                                                                                                                                                                                                                                                                      Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                      type CustomUserAgentDetails

                                                                                                                                                                                                                                                                                                                                                                                                                      type CustomUserAgentDetails =
                                                                                                                                                                                                                                                                                                                                                                                                                      | (CustomUserAgentDetailsBase & {
                                                                                                                                                                                                                                                                                                                                                                                                                      category?: never;
                                                                                                                                                                                                                                                                                                                                                                                                                      action?: never;
                                                                                                                                                                                                                                                                                                                                                                                                                      })
                                                                                                                                                                                                                                                                                                                                                                                                                      | UserAgentDetailsWithCategory<Category.API>
                                                                                                                                                                                                                                                                                                                                                                                                                      | UserAgentDetailsWithCategory<Category.Auth>
                                                                                                                                                                                                                                                                                                                                                                                                                      | UserAgentDetailsWithCategory<Category.Analytics>
                                                                                                                                                                                                                                                                                                                                                                                                                      | UserAgentDetailsWithCategory<Category.DataStore>
                                                                                                                                                                                                                                                                                                                                                                                                                      | UserAgentDetailsWithCategory<Category.Geo>
                                                                                                                                                                                                                                                                                                                                                                                                                      | UserAgentDetailsWithCategory<Category.Interactions>
                                                                                                                                                                                                                                                                                                                                                                                                                      | UserAgentDetailsWithCategory<Category.InAppMessaging>
                                                                                                                                                                                                                                                                                                                                                                                                                      | UserAgentDetailsWithCategory<Category.Predictions>
                                                                                                                                                                                                                                                                                                                                                                                                                      | UserAgentDetailsWithCategory<Category.PubSub>
                                                                                                                                                                                                                                                                                                                                                                                                                      | UserAgentDetailsWithCategory<Category.PushNotification>
                                                                                                                                                                                                                                                                                                                                                                                                                      | UserAgentDetailsWithCategory<Category.Storage>;

                                                                                                                                                                                                                                                                                                                                                                                                                        type HubCallback

                                                                                                                                                                                                                                                                                                                                                                                                                        type HubCallback = (capsule: HubCapsule) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                          type HubCapsule

                                                                                                                                                                                                                                                                                                                                                                                                                          type HubCapsule = {
                                                                                                                                                                                                                                                                                                                                                                                                                          channel: string;
                                                                                                                                                                                                                                                                                                                                                                                                                          payload: HubPayload;
                                                                                                                                                                                                                                                                                                                                                                                                                          source: string;
                                                                                                                                                                                                                                                                                                                                                                                                                          patternInfo?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                            type HubPayload

                                                                                                                                                                                                                                                                                                                                                                                                                            type HubPayload = {
                                                                                                                                                                                                                                                                                                                                                                                                                            event: string;
                                                                                                                                                                                                                                                                                                                                                                                                                            data?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                            message?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                              Package Files (28)

                                                                                                                                                                                                                                                                                                                                                                                                                              Dependencies (10)

                                                                                                                                                                                                                                                                                                                                                                                                                              Dev Dependencies (5)

                                                                                                                                                                                                                                                                                                                                                                                                                              Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                              No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                              Badge

                                                                                                                                                                                                                                                                                                                                                                                                                              To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                              You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@aws-amplify/core.

                                                                                                                                                                                                                                                                                                                                                                                                                              • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@aws-amplify/core)
                                                                                                                                                                                                                                                                                                                                                                                                                              • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                <a href="https://www.jsdocs.io/package/@aws-amplify/core"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>