@aws-amplify/analytics 6.5.6-api-v6-models.b3abc9b.0 → 7.0.0

package/lib-esm/providers/personalize/utils/autoTrackMedia.js

@@ -0,0 +1,177 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { isBrowser } from '@aws-amplify/core/internals/utils';
+import { ConsoleLogger } from '@aws-amplify/core';
+var HTML5_MEDIA_EVENT;
+(function (HTML5_MEDIA_EVENT) {
+    HTML5_MEDIA_EVENT["PLAY"] = "play";
+    HTML5_MEDIA_EVENT["PAUSE"] = "pause";
+    HTML5_MEDIA_EVENT["ENDED"] = "Ended";
+})(HTML5_MEDIA_EVENT || (HTML5_MEDIA_EVENT = {}));
+var MEDIA_TYPE;
+(function (MEDIA_TYPE) {
+    MEDIA_TYPE["IFRAME"] = "IFRAME";
+    MEDIA_TYPE["VIDEO"] = "VIDEO";
+    MEDIA_TYPE["AUDIO"] = "AUDIO";
+})(MEDIA_TYPE || (MEDIA_TYPE = {}));
+var EVENT_TYPE;
+(function (EVENT_TYPE) {
+    EVENT_TYPE["PLAY"] = "Play";
+    EVENT_TYPE["ENDED"] = "Ended";
+    EVENT_TYPE["PAUSE"] = "Pause";
+    EVENT_TYPE["TIME_WATCHED"] = "TimeWatched";
+})(EVENT_TYPE || (EVENT_TYPE = {}));
+const logger = new ConsoleLogger('MediaAutoTrack');
+const startIframeAutoTracking = (element, recordEvent) => {
+    let isPlaying = false;
+    let player;
+    const mediaProperties = () => {
+        const duration = Number(parseFloat(player.getDuration()).toFixed(4));
+        const currentTime = Number(parseFloat(player.getCurrentTime()).toFixed(4));
+        return {
+            duration,
+            eventValue: Number((currentTime / duration).toFixed(4)),
+        };
+    };
+    const scriptElement = document.createElement('script');
+    scriptElement.type = 'text/javascript';
+    scriptElement.src = 'https://www.youtube.com/iframe_api';
+    document.body.append(scriptElement);
+    const timer = setInterval(() => {
+        if (isPlaying && player) {
+            recordEvent(EVENT_TYPE.TIME_WATCHED, mediaProperties());
+        }
+    }, 3000);
+    element.addEventListener('unload', () => clearInterval(timer));
+    // @ts-ignore
+    window.onYouTubeIframeAPIReady = () => {
+        // @ts-ignore
+        delete window.onYouTubeIframeAPIReady;
+        // @ts-ignore
+        player = new window.YT.Player(element.id, {
+            events: {
+                onStateChange: (event) => {
+                    const iframeEventMapping = {
+                        0: EVENT_TYPE.ENDED,
+                        1: EVENT_TYPE.PLAY,
+                        2: EVENT_TYPE.PAUSE,
+                    };
+                    // @ts-ignore
+                    const eventType = iframeEventMapping[event.data];
+                    switch (eventType) {
+                        case EVENT_TYPE.ENDED:
+                        case EVENT_TYPE.PAUSE:
+                            isPlaying = false;
+                            break;
+                        case EVENT_TYPE.PLAY:
+                            isPlaying = true;
+                            break;
+                    }
+                    if (eventType) {
+                        recordEvent(eventType, mediaProperties());
+                    }
+                },
+            },
+        });
+    };
+};
+const startHTMLMediaAutoTracking = (element, recordEvent) => {
+    let isPlaying = false;
+    const mediaProperties = () => ({
+        duration: element.duration,
+        eventValue: Number((element.currentTime / element.duration).toFixed(4)),
+    });
+    const timer = setInterval(() => {
+        if (isPlaying) {
+            recordEvent(EVENT_TYPE.TIME_WATCHED, mediaProperties());
+        }
+    }, 3000);
+    element.addEventListener('unload', () => clearInterval(timer));
+    element.addEventListener(HTML5_MEDIA_EVENT.PLAY, () => {
+        isPlaying = true;
+        recordEvent(EVENT_TYPE.PLAY, mediaProperties());
+    });
+    element.addEventListener(HTML5_MEDIA_EVENT.PAUSE, () => {
+        isPlaying = false;
+        recordEvent(EVENT_TYPE.PAUSE, mediaProperties());
+    });
+    element.addEventListener(HTML5_MEDIA_EVENT.ENDED, () => {
+        isPlaying = false;
+        recordEvent(EVENT_TYPE.ENDED, mediaProperties());
+    });
+};
+const checkElementLoaded = (interval, maxTries) => {
+    let retryCount = 0;
+    const wait = () => new Promise(r => setTimeout(r, interval));
+    const check = async (elementId) => {
+        if (retryCount >= maxTries) {
+            return false;
+        }
+        const domElement = document.getElementById(elementId);
+        if (domElement && domElement.clientHeight) {
+            return true;
+        }
+        else {
+            retryCount += 1;
+            await wait();
+            return await check(elementId);
+        }
+    };
+    return check;
+};
+const recordEvent = (config, eventBuffer) => (eventType, properties) => {
+    // override eventType and merge properties
+    eventBuffer.append({
+        ...config,
+        event: {
+            ...config.event,
+            eventType,
+            properties: {
+                ...config.event.properties,
+                ...properties,
+            },
+        },
+        timestamp: Date.now(),
+    });
+};
+export const autoTrackMedia = async (config, eventBuffer) => {
+    const { eventType, properties } = config.event;
+    const { domElementId, ...otherProperties } = properties;
+    if (!isBrowser()) {
+        logger.debug(`${eventType} only for browser`);
+        return;
+    }
+    if (typeof domElementId === 'string' && !domElementId) {
+        logger.debug("Missing domElementId field in 'properties' for MediaAutoTrack event type.");
+        return;
+    }
+    const elementId = domElementId;
+    const isElementLoaded = await checkElementLoaded(500, 5)(elementId);
+    if (isElementLoaded) {
+        const autoTrackConfigWithoutDomElementId = {
+            ...config,
+            event: {
+                ...config.event,
+                properties: otherProperties,
+            },
+        };
+        const element = document.getElementById(elementId);
+        switch (element?.tagName) {
+            case MEDIA_TYPE.IFRAME:
+                startIframeAutoTracking(element, recordEvent(autoTrackConfigWithoutDomElementId, eventBuffer));
+                break;
+            case MEDIA_TYPE.VIDEO:
+            case MEDIA_TYPE.AUDIO:
+                if (element instanceof HTMLMediaElement) {
+                    startHTMLMediaAutoTracking(element, recordEvent(autoTrackConfigWithoutDomElementId, eventBuffer));
+                }
+                break;
+            default:
+                logger.debug(`Unsupported DOM element tag: ${element?.tagName}`);
+                break;
+        }
+    }
+    else {
+        logger.debug('Cannot find the media element.');
+    }
+};

package/lib-esm/providers/personalize/utils/cachedSession.d.ts

@@ -0,0 +1,5 @@
+export declare const resolveCachedSession: () => Promise<{
+    sessionId: string;
+    userId: string | undefined;
+}>;
+export declare const updateCachedSession: (newUserId?: string, currentSessionId?: string, currentUserId?: string) => void;

package/lib-esm/providers/personalize/utils/cachedSession.js

@@ -0,0 +1,44 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { Cache } from '@aws-amplify/core';
+import { isBrowser, amplifyUuid } from '@aws-amplify/core/internals/utils';
+const PERSONALIZE_CACHE_USERID = '_awsct_uid';
+const PERSONALIZE_CACHE_SESSIONID = '_awsct_sid';
+const DEFAULT_CACHE_PREFIX = 'personalize';
+const DELIMITER = '.';
+const CACHE_EXPIRY_IN_DAYS = 7;
+const normalize = (key) => [key, isBrowser() ? window.location.host : DEFAULT_CACHE_PREFIX].join(DELIMITER);
+const getCache = (key) => Cache.getItem(normalize(key));
+const setCache = (key, value) => {
+    const expiredAt = new Date(Date.now() + 3600000 * 24 * CACHE_EXPIRY_IN_DAYS);
+    Cache.setItem(normalize(key), value, {
+        expires: expiredAt.getTime(),
+    });
+};
+export const resolveCachedSession = async () => {
+    let sessionId = await getCache(PERSONALIZE_CACHE_SESSIONID);
+    if (!sessionId) {
+        sessionId = amplifyUuid();
+        setCache(PERSONALIZE_CACHE_SESSIONID, sessionId);
+    }
+    const userId = await getCache(PERSONALIZE_CACHE_USERID);
+    return {
+        sessionId,
+        userId,
+    };
+};
+export const updateCachedSession = (newUserId, currentSessionId, currentUserId) => {
+    const isNoCachedSession = !currentSessionId;
+    const isSignOutCase = !newUserId && !currentUserId;
+    const isSwitchUserCase = !!newUserId && !!currentUserId && newUserId !== currentUserId;
+    const isRequireNewSession = isNoCachedSession || isSignOutCase || isSwitchUserCase;
+    const isRequireUpdateSession = !!currentSessionId && !currentUserId && !!newUserId;
+    if (isRequireNewSession) {
+        const newSessionId = amplifyUuid();
+        setCache(PERSONALIZE_CACHE_SESSIONID, newSessionId);
+        setCache(PERSONALIZE_CACHE_USERID, newUserId);
+    }
+    else if (isRequireUpdateSession) {
+        setCache(PERSONALIZE_CACHE_USERID, newUserId);
+    }
+};

package/lib-esm/providers/personalize/utils/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const DEFAULT_PERSONALIZE_CONFIG: {
+    flushSize: number;
+    flushInterval: number;
+};
+export declare const PERSONALIZE_FLUSH_SIZE_MAX = 10;
+export declare const IDENTIFY_EVENT_TYPE = "Identify";
+export declare const MEDIA_AUTO_TRACK_EVENT_TYPE = "MediaAutoTrack";

package/lib-esm/providers/personalize/utils/constants.js

@@ -0,0 +1,9 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+export const DEFAULT_PERSONALIZE_CONFIG = {
+    flushSize: 5,
+    flushInterval: 5000,
+};
+export const PERSONALIZE_FLUSH_SIZE_MAX = 10;
+export const IDENTIFY_EVENT_TYPE = 'Identify';
+export const MEDIA_AUTO_TRACK_EVENT_TYPE = 'MediaAutoTrack';

package/lib-esm/providers/personalize/utils/getEventBuffer.d.ts

@@ -0,0 +1,3 @@
+import { EventBuffer } from '../../../utils';
+import { PersonalizeBufferConfig, PersonalizeBufferEvent } from '../types';
+export declare const getEventBuffer: ({ region, flushSize, flushInterval, bufferSize, credentials, identityId, userAgentValue, }: PersonalizeBufferConfig) => EventBuffer<PersonalizeBufferEvent>;

package/lib-esm/providers/personalize/utils/getEventBuffer.js

@@ -0,0 +1,69 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { EventBuffer, groupBy } from '../../../utils';
+import { PersonalizeEventsClient, PutEventsCommand, } from '@aws-sdk/client-personalize-events';
+/**
+ * These Records hold cached event buffers and AWS clients.
+ * The hash key is determined by the region and session,
+ * consisting of a combined value comprising [region, sessionToken, identityId].
+ *
+ * Only one active session should exist at any given moment.
+ * When a new session is initiated, the previous ones should be released.
+ * */
+const eventBufferMap = {};
+const cachedClients = {};
+const DELIMITER = '#';
+const createPutEventsCommand = (ids, events) => {
+    const [trackingId, sessionId, userId] = ids.split(DELIMITER);
+    return new PutEventsCommand({
+        trackingId,
+        sessionId,
+        userId,
+        eventList: events.map(event => ({
+            eventId: event.event.eventId,
+            eventType: event.event.eventType,
+            properties: JSON.stringify(event.event.properties),
+            sentAt: new Date(event.timestamp),
+        })),
+    });
+};
+const submitEvents = async (events, client) => {
+    const groupedByIds = Object.entries(groupBy(event => [event.trackingId, event.sessionId, event.userId]
+        .filter(id => !!id)
+        .join(DELIMITER), events));
+    const requests = groupedByIds
+        .map(([ids, events]) => createPutEventsCommand(ids, events))
+        .map(command => client.send(command));
+    await Promise.allSettled(requests);
+    return Promise.resolve([]);
+};
+export const getEventBuffer = ({ region, flushSize, flushInterval, bufferSize, credentials, identityId, userAgentValue, }) => {
+    const sessionIdentityKey = [region, identityId].filter(x => !!x).join('-');
+    if (!eventBufferMap[sessionIdentityKey]) {
+        const getClient = () => {
+            if (!cachedClients[sessionIdentityKey]) {
+                cachedClients[sessionIdentityKey] = new PersonalizeEventsClient({
+                    region,
+                    credentials,
+                    customUserAgent: userAgentValue,
+                });
+            }
+            return events => submitEvents(events, cachedClients[sessionIdentityKey]);
+        };
+        eventBufferMap[sessionIdentityKey] =
+            new EventBuffer({
+                bufferSize,
+                flushSize,
+                flushInterval,
+            }, getClient);
+        const releaseSessionKeys = Object.keys(eventBufferMap).filter(key => key !== sessionIdentityKey);
+        for (const releaseSessionKey of releaseSessionKeys) {
+            eventBufferMap[releaseSessionKey].flushAll().finally(() => {
+                eventBufferMap[releaseSessionKey].release();
+                delete eventBufferMap[releaseSessionKey];
+                delete cachedClients[releaseSessionKey];
+            });
+        }
+    }
+    return eventBufferMap[sessionIdentityKey];
+};

package/lib-esm/providers/personalize/utils/index.d.ts

@@ -0,0 +1,5 @@
+export { getEventBuffer } from './getEventBuffer';
+export { resolveConfig } from './resolveConfig';
+export { autoTrackMedia } from './autoTrackMedia';
+export { resolveCachedSession, updateCachedSession } from './cachedSession';
+export { DEFAULT_PERSONALIZE_CONFIG, PERSONALIZE_FLUSH_SIZE_MAX, } from './constants';

package/lib-esm/providers/personalize/utils/index.js

@@ -0,0 +1,7 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+export { getEventBuffer } from './getEventBuffer';
+export { resolveConfig } from './resolveConfig';
+export { autoTrackMedia } from './autoTrackMedia';
+export { resolveCachedSession, updateCachedSession } from './cachedSession';
+export { DEFAULT_PERSONALIZE_CONFIG, PERSONALIZE_FLUSH_SIZE_MAX, } from './constants';

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

@@ -0,0 +1,7 @@
+export declare const resolveConfig: () => {
+    region: string;
+    trackingId: string;
+    bufferSize: number;
+    flushSize: number;
+    flushInterval: number;
+};

package/lib-esm/providers/personalize/utils/resolveConfig.js

@@ -0,0 +1,22 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { Amplify } from '@aws-amplify/core';
+import { AnalyticsValidationErrorCode, assertValidationError, } from '../../../errors';
+import { DEFAULT_PERSONALIZE_CONFIG, PERSONALIZE_FLUSH_SIZE_MAX } from './';
+export const resolveConfig = () => {
+    const config = Amplify.getConfig().Analytics?.Personalize;
+    const { region, trackingId, flushSize = DEFAULT_PERSONALIZE_CONFIG.flushSize, flushInterval = DEFAULT_PERSONALIZE_CONFIG.flushInterval, } = {
+        ...DEFAULT_PERSONALIZE_CONFIG,
+        ...config,
+    };
+    assertValidationError(!!region, AnalyticsValidationErrorCode.NoRegion);
+    assertValidationError(!!trackingId, AnalyticsValidationErrorCode.NoTrackingId);
+    assertValidationError(flushSize <= PERSONALIZE_FLUSH_SIZE_MAX, AnalyticsValidationErrorCode.InvalidFlushSize, `FlushSize for Personalize should be less or equal than ${PERSONALIZE_FLUSH_SIZE_MAX}`);
+    return {
+        region,
+        trackingId,
+        bufferSize: flushSize + 1,
+        flushSize,
+        flushInterval,
+    };
+};

package/lib-esm/providers/pinpoint/apis/configureAutoTrack.d.ts

@@ -0,0 +1,15 @@
+import { ConfigureAutoTrackInput } from '../types';
+/**
+ * Configures automatic event tracking for Pinpoint. This API will automatically transmit an analytic event when
+ * configured events are detected within your application. This can include: DOM element events (via the `event`
+ * tracker), session events (via the `session` tracker), and page view events (via the `pageView` tracker).
+ *
+ * @remark Only session tracking is currently supported on React Native.
+ *
+ * @param {ConfigureAutoTrackInput} params The input object to configure auto track behavior.
+ *
+ * @throws service: {@link UpdateEndpointException} - Thrown when the underlying Pinpoint service returns an error.
+ * @throws validation: {@link AnalyticsValidationErrorCode} - Thrown when the provided parameters or library
+ *  configuration is incorrect.
+ */
+export declare const configureAutoTrack: (input: ConfigureAutoTrackInput) => void;

package/lib-esm/providers/pinpoint/apis/configureAutoTrack.js

@@ -0,0 +1,31 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { updateProviderTrackers, validateTrackerConfiguration, } from '../../../utils';
+import { record } from './record';
+// Configured Tracker instances for Pinpoint
+const configuredTrackers = {};
+// Callback that will emit an appropriate event to Pinpoint when required by the Tracker
+const emitTrackingEvent = (eventName, attributes) => {
+    record({
+        name: eventName,
+        attributes,
+    });
+};
+/**
+ * Configures automatic event tracking for Pinpoint. This API will automatically transmit an analytic event when
+ * configured events are detected within your application. This can include: DOM element events (via the `event`
+ * tracker), session events (via the `session` tracker), and page view events (via the `pageView` tracker).
+ *
+ * @remark Only session tracking is currently supported on React Native.
+ *
+ * @param {ConfigureAutoTrackInput} params The input object to configure auto track behavior.
+ *
+ * @throws service: {@link UpdateEndpointException} - Thrown when the underlying Pinpoint service returns an error.
+ * @throws validation: {@link AnalyticsValidationErrorCode} - Thrown when the provided parameters or library
+ *  configuration is incorrect.
+ */
+export const configureAutoTrack = (input) => {
+    validateTrackerConfiguration(input);
+    // Initialize or update this provider's trackers
+    updateProviderTrackers(input, emitTrackingEvent, configuredTrackers);
+};

package/lib-esm/providers/pinpoint/apis/flushEvents.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Flushes all buffered Pinpoint events to the service.
+ *
+ * @note
+ * This API will make a best-effort attempt to flush events from the buffer. Events recorded immediately after invoking
+ * this API may not be included in the flush.
+ */
+export declare const flushEvents: () => void;

package/lib-esm/providers/pinpoint/apis/flushEvents.js

@@ -0,0 +1,21 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { resolveConfig, resolveCredentials } from '../utils';
+import { flushEvents as flushEventsCore } from '@aws-amplify/core/internals/providers/pinpoint';
+import { AnalyticsAction } from '@aws-amplify/core/internals/utils';
+import { ConsoleLogger } from '@aws-amplify/core';
+import { getAnalyticsUserAgentString } from '../../../utils';
+const logger = new ConsoleLogger('Analytics');
+/**
+ * Flushes all buffered Pinpoint events to the service.
+ *
+ * @note
+ * This API will make a best-effort attempt to flush events from the buffer. Events recorded immediately after invoking
+ * this API may not be included in the flush.
+ */
+export const flushEvents = () => {
+    const { appId, region } = resolveConfig();
+    resolveCredentials()
+        .then(({ credentials, identityId }) => flushEventsCore(appId, region, credentials, identityId, getAnalyticsUserAgentString(AnalyticsAction.Record)))
+        .catch(e => logger.warn('Failed to flush events', e));
+};

package/lib-esm/providers/pinpoint/apis/identifyUser.d.ts

@@ -0,0 +1,47 @@
+import { IdentifyUserInput } from '../types';
+/**
+ * Sends information about a user to Pinpoint. Sending user information allows you to associate a user to their user
+ * profile and activities or actions in your application. Activity can be tracked across devices & platforms by using
+ * the same `userId`.
+ *
+ * @param {IdentifyUserParameters} params The input object used to construct requests sent to Pinpoint's UpdateEndpoint
+ *  API.
+ *
+ * @throws service: {@link UpdateEndpointException} - Thrown when the underlying Pinpoint service returns an error.
+ * @throws validation: {@link AnalyticsValidationErrorCode} - Thrown when the provided parameters or library
+ *  configuration is incorrect.
+ *
+ * @returns A promise that will resolve when the operation is complete.
+ *
+ * @example
+ * ```ts
+ * // Identify a user with Pinpoint
+ * await identifyUser({
+ *     userId,
+ *     userProfile: {
+ *         email: 'userEmail@example.com'
+ *         customProperties: {
+ *             phoneNumber: ['555-555-5555'],
+ *         },
+ *     }
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Identify a user with Pinpoint with some additional demographics
+ * await identifyUser({
+ *     userId,
+ *     userProfile: {
+ *         email: 'userEmail@example.com'
+ *         customProperties: {
+ *             phoneNumber: ['555-555-5555'],
+ *         },
+ *         demographic: {
+ *             platform: 'ios',
+ *             timezone: 'America/Los_Angeles'
+ *         }
+ *     }
+ * });
+ */
+export declare const identifyUser: ({ userId, userProfile, options, }: IdentifyUserInput) => Promise<void>;

package/lib-esm/providers/pinpoint/apis/identifyUser.js

@@ -0,0 +1,67 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { AnalyticsAction } from '@aws-amplify/core/internals/utils';
+import { updateEndpoint, } from '@aws-amplify/core/internals/providers/pinpoint';
+import { getAnalyticsUserAgentString } from '../../../utils';
+import { resolveConfig, resolveCredentials } from '../utils';
+/**
+ * Sends information about a user to Pinpoint. Sending user information allows you to associate a user to their user
+ * profile and activities or actions in your application. Activity can be tracked across devices & platforms by using
+ * the same `userId`.
+ *
+ * @param {IdentifyUserParameters} params The input object used to construct requests sent to Pinpoint's UpdateEndpoint
+ *  API.
+ *
+ * @throws service: {@link UpdateEndpointException} - Thrown when the underlying Pinpoint service returns an error.
+ * @throws validation: {@link AnalyticsValidationErrorCode} - Thrown when the provided parameters or library
+ *  configuration is incorrect.
+ *
+ * @returns A promise that will resolve when the operation is complete.
+ *
+ * @example
+ * ```ts
+ * // Identify a user with Pinpoint
+ * await identifyUser({
+ *     userId,
+ *     userProfile: {
+ *         email: 'userEmail@example.com'
+ *         customProperties: {
+ *             phoneNumber: ['555-555-5555'],
+ *         },
+ *     }
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Identify a user with Pinpoint with some additional demographics
+ * await identifyUser({
+ *     userId,
+ *     userProfile: {
+ *         email: 'userEmail@example.com'
+ *         customProperties: {
+ *             phoneNumber: ['555-555-5555'],
+ *         },
+ *         demographic: {
+ *             platform: 'ios',
+ *             timezone: 'America/Los_Angeles'
+ *         }
+ *     }
+ * });
+ */
+export const identifyUser = async ({ userId, userProfile, options, }) => {
+    const { credentials, identityId } = await resolveCredentials();
+    const { appId, region } = resolveConfig();
+    const { userAttributes } = options ?? {};
+    updateEndpoint({
+        appId,
+        category: 'Analytics',
+        credentials,
+        identityId,
+        region,
+        userAttributes,
+        userId,
+        userProfile,
+        userAgentValue: getAnalyticsUserAgentString(AnalyticsAction.IdentifyUser),
+    });
+};

package/lib-esm/providers/pinpoint/apis/index.d.ts

@@ -0,0 +1,4 @@
+export { record } from './record';
+export { identifyUser } from './identifyUser';
+export { configureAutoTrack } from './configureAutoTrack';
+export { flushEvents } from './flushEvents';

package/lib-esm/providers/pinpoint/apis/index.js

@@ -0,0 +1,6 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+export { record } from './record';
+export { identifyUser } from './identifyUser';
+export { configureAutoTrack } from './configureAutoTrack';
+export { flushEvents } from './flushEvents';

package/lib-esm/providers/pinpoint/apis/record.d.ts

@@ -0,0 +1,30 @@
+import { RecordInput } from '../types';
+/**
+ * Records an Analytic event to Pinpoint. Events will be buffered and periodically sent to Pinpoint.
+ *
+ * @param {RecordInput} params The input object used to construct the request.
+ *
+ * @throws validation: {@link AnalyticsValidationErrorCode} - Thrown when the provided parameters or library
+ *  configuration is incorrect.
+ *
+ * @example
+ * ```ts
+ * // Send an event to Pinpoint
+ * record({ name: eventName })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Send an event to Pinpoint with metrics & custom attributes
+ * record({
+ *     name: eventName,
+ *     attributes: {
+ *         'my-attribute': attributeValue
+ *     },
+ *     metrics: {
+ *         'my-metric': metricValue
+ *     }
+ * })
+ * ```
+ */
+export declare const record: (input: RecordInput) => void;