@aws-amplify/backend-notifications 0.0.0-test-20260708085627

package/lib/lambda/campaign-association/integration.d.ts

@@ -0,0 +1,59 @@
+import { IAMClient } from '@aws-sdk/client-iam';
+import { ConnectCampaignsV2Client } from '@aws-sdk/client-connectcampaignsv2';
+import { CustomerProfilesClient } from '@aws-sdk/client-customer-profiles';
+/** Customer Profiles domain ARN for a domain name in the deploy account/region. */
+export declare const domainArnOf: (account: string, region: string, domainName: string) => string;
+/** connect-campaigns instance ARN used as the Customer Profiles integration Uri. */
+export declare const campaignsInstanceArnOf: (account: string, region: string, connectInstanceId: string) => string;
+/**
+ * Resolve the Outbound Campaigns service-linked role ARN
+ * (`AWSServiceRoleForConnectCampaigns_*`), which StartInstanceOnboardingJob
+ * auto-creates under `/aws-service-role/connect-campaigns.amazonaws.com/`. The
+ * newest role (last in the returned list) is used, matching the empirically
+ * verified recipe.
+ */
+export declare const resolveCampaignsServiceLinkedRoleArn: (iam: IAMClient) => Promise<string>;
+/**
+ * Associate the (created) Customer Profiles domain with the Connect instance's
+ * Outbound Campaigns v2 so Connect Journeys can target the domain's profiles:
+ *   1. connectcampaignsv2:PutConnectInstanceIntegration — binds the domain ARN.
+ *   2. customer-profiles:PutIntegration — the reciprocal binding, using the
+ *      campaigns service-linked role.
+ * Succeeds on an EMPTY domain: `objectTypeNames` is a label/routing map to
+ * BUILT-IN templates, so no object types need pre-creating.
+ */
+export declare const associateDomain: (clients: {
+    campaigns: ConnectCampaignsV2Client;
+    profiles: CustomerProfilesClient;
+    iam: IAMClient;
+}, args: {
+    connectInstanceId: string;
+    domainName: string;
+    roleArn: string;
+    account: string;
+    region: string;
+}) => Promise<void>;
+/**
+ * Best-effort reverse of {@link associateDomain} on stack teardown. Each step is
+ * idempotent and swallows errors (logged) so a missing / already-removed
+ * integration — e.g. when CloudFormation deleted the parent instance / domain
+ * FIRST — NEVER fails teardown. Reverses everything onCreate did:
+ *   1. connectcampaignsv2:DeleteConnectInstanceIntegration (campaigns -> domain)
+ *   2. customer-profiles:DeleteIntegration (domain -> campaigns)
+ *   3. connectcampaignsv2:DeleteInstanceOnboardingJob (offboard from Campaigns v2)
+ *
+ * The `AWSServiceRoleForConnectCampaigns_*` service-linked role is deliberately
+ * NOT deleted: it is account-wide, shared across ALL Connect instances /
+ * campaigns in the account, free, and harmless — deleting it could break other
+ * instances still onboarded to Outbound Campaigns.
+ */
+export declare const disassociateDomain: (clients: {
+    campaigns: ConnectCampaignsV2Client;
+    profiles: CustomerProfilesClient;
+}, args: {
+    connectInstanceId: string;
+    domainName: string;
+    account: string;
+    region: string;
+}) => Promise<void>;
+//# sourceMappingURL=integration.d.ts.map

package/lib/lambda/campaign-association/integration.js

@@ -0,0 +1,108 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { ListRolesCommand } from '@aws-sdk/client-iam';
+import { DeleteConnectInstanceIntegrationCommand, DeleteInstanceOnboardingJobCommand, PutConnectInstanceIntegrationCommand, } from '@aws-sdk/client-connectcampaignsv2';
+import { DeleteIntegrationCommand, PutIntegrationCommand, } from '@aws-sdk/client-customer-profiles';
+import { CAMPAIGN_OBJECT_TYPE_NAMES, CONNECT_CAMPAIGNS_SLR_PATH_PREFIX, } from '../../constants.js';
+/** Object-type routing map supplied to both integration calls. */
+const objectTypeNames = { ...CAMPAIGN_OBJECT_TYPE_NAMES };
+/** Customer Profiles domain ARN for a domain name in the deploy account/region. */
+export const domainArnOf = (account, region, domainName) => `arn:aws:profile:${region}:${account}:domains/${domainName}`;
+/** connect-campaigns instance ARN used as the Customer Profiles integration Uri. */
+export const campaignsInstanceArnOf = (account, region, connectInstanceId) => `arn:aws:connect-campaigns:${region}:${account}:instance/${connectInstanceId}`;
+/**
+ * Resolve the Outbound Campaigns service-linked role ARN
+ * (`AWSServiceRoleForConnectCampaigns_*`), which StartInstanceOnboardingJob
+ * auto-creates under `/aws-service-role/connect-campaigns.amazonaws.com/`. The
+ * newest role (last in the returned list) is used, matching the empirically
+ * verified recipe.
+ */
+export const resolveCampaignsServiceLinkedRoleArn = async (iam) => {
+    const { Roles: roles } = await iam.send(new ListRolesCommand({ PathPrefix: CONNECT_CAMPAIGNS_SLR_PATH_PREFIX }));
+    const arn = roles?.[roles.length - 1]?.Arn;
+    if (!arn) {
+        throw new Error('Outbound Campaigns service-linked role not found after onboarding');
+    }
+    return arn;
+};
+/**
+ * Associate the (created) Customer Profiles domain with the Connect instance's
+ * Outbound Campaigns v2 so Connect Journeys can target the domain's profiles:
+ *   1. connectcampaignsv2:PutConnectInstanceIntegration — binds the domain ARN.
+ *   2. customer-profiles:PutIntegration — the reciprocal binding, using the
+ *      campaigns service-linked role.
+ * Succeeds on an EMPTY domain: `objectTypeNames` is a label/routing map to
+ * BUILT-IN templates, so no object types need pre-creating.
+ */
+export const associateDomain = async (clients, args) => {
+    const { campaigns, profiles } = clients;
+    const { connectInstanceId, domainName, roleArn, account, region } = args;
+    const domainArn = domainArnOf(account, region, domainName);
+    await campaigns.send(new PutConnectInstanceIntegrationCommand({
+        connectInstanceId,
+        integrationConfig: {
+            customerProfiles: { domainArn, objectTypeNames },
+        },
+    }));
+    console.log('[campaign-assoc] connect instance integration created', {
+        connectInstanceId,
+        domainArn,
+    });
+    await profiles.send(new PutIntegrationCommand({
+        DomainName: domainName,
+        Uri: campaignsInstanceArnOf(account, region, connectInstanceId),
+        ObjectTypeNames: objectTypeNames,
+        RoleArn: roleArn,
+    }));
+    console.log('[campaign-assoc] customer profiles integration created', {
+        domainName,
+        connectInstanceId,
+    });
+};
+/**
+ * Best-effort reverse of {@link associateDomain} on stack teardown. Each step is
+ * idempotent and swallows errors (logged) so a missing / already-removed
+ * integration — e.g. when CloudFormation deleted the parent instance / domain
+ * FIRST — NEVER fails teardown. Reverses everything onCreate did:
+ *   1. connectcampaignsv2:DeleteConnectInstanceIntegration (campaigns -> domain)
+ *   2. customer-profiles:DeleteIntegration (domain -> campaigns)
+ *   3. connectcampaignsv2:DeleteInstanceOnboardingJob (offboard from Campaigns v2)
+ *
+ * The `AWSServiceRoleForConnectCampaigns_*` service-linked role is deliberately
+ * NOT deleted: it is account-wide, shared across ALL Connect instances /
+ * campaigns in the account, free, and harmless — deleting it could break other
+ * instances still onboarded to Outbound Campaigns.
+ */
+export const disassociateDomain = async (clients, args) => {
+    const { campaigns, profiles } = clients;
+    const { connectInstanceId, domainName, account, region } = args;
+    await bestEffort('connect instance integration delete', () => campaigns.send(new DeleteConnectInstanceIntegrationCommand({
+        connectInstanceId,
+        integrationIdentifier: {
+            customerProfiles: {
+                domainArn: domainArnOf(account, region, domainName),
+            },
+        },
+    })));
+    await bestEffort('customer profiles integration delete', () => profiles.send(new DeleteIntegrationCommand({
+        DomainName: domainName,
+        Uri: campaignsInstanceArnOf(account, region, connectInstanceId),
+    })));
+    await bestEffort('instance offboarding', () => campaigns.send(new DeleteInstanceOnboardingJobCommand({ connectInstanceId })));
+};
+/**
+ * Run a teardown step, swallowing (and logging) any error so a partial /
+ * already-removed resource never fails CloudFormation teardown.
+ */
+const bestEffort = async (label, fn) => {
+    try {
+        await fn();
+        console.log(`[campaign-assoc] ${label} ok`);
+    }
+    catch (err) {
+        console.warn(`[campaign-assoc] ${label} skipped`, {
+            error: err?.name ?? 'unknown',
+        });
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"integration.js","sourceRoot":"","sources":["../../../src/lambda/campaign-association/integration.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// SPDX-License-Identifier: Apache-2.0\n\nimport { IAMClient, ListRolesCommand } from '@aws-sdk/client-iam';\nimport {\n  ConnectCampaignsV2Client,\n  DeleteConnectInstanceIntegrationCommand,\n  DeleteInstanceOnboardingJobCommand,\n  PutConnectInstanceIntegrationCommand,\n} from '@aws-sdk/client-connectcampaignsv2';\nimport {\n  CustomerProfilesClient,\n  DeleteIntegrationCommand,\n  PutIntegrationCommand,\n} from '@aws-sdk/client-customer-profiles';\n\nimport {\n  CAMPAIGN_OBJECT_TYPE_NAMES,\n  CONNECT_CAMPAIGNS_SLR_PATH_PREFIX,\n} from '../../constants.js';\n\n/** Object-type routing map supplied to both integration calls. */\nconst objectTypeNames = { ...CAMPAIGN_OBJECT_TYPE_NAMES };\n\n/** Customer Profiles domain ARN for a domain name in the deploy account/region. */\nexport const domainArnOf = (\n  account: string,\n  region: string,\n  domainName: string,\n): string => `arn:aws:profile:${region}:${account}:domains/${domainName}`;\n\n/** connect-campaigns instance ARN used as the Customer Profiles integration Uri. */\nexport const campaignsInstanceArnOf = (\n  account: string,\n  region: string,\n  connectInstanceId: string,\n): string =>\n  `arn:aws:connect-campaigns:${region}:${account}:instance/${connectInstanceId}`;\n\n/**\n * Resolve the Outbound Campaigns service-linked role ARN\n * (`AWSServiceRoleForConnectCampaigns_*`), which StartInstanceOnboardingJob\n * auto-creates under `/aws-service-role/connect-campaigns.amazonaws.com/`. The\n * newest role (last in the returned list) is used, matching the empirically\n * verified recipe.\n */\nexport const resolveCampaignsServiceLinkedRoleArn = async (\n  iam: IAMClient,\n): Promise<string> => {\n  const { Roles: roles } = await iam.send(\n    new ListRolesCommand({ PathPrefix: CONNECT_CAMPAIGNS_SLR_PATH_PREFIX }),\n  );\n  const arn = roles?.[roles.length - 1]?.Arn;\n  if (!arn) {\n    throw new Error(\n      'Outbound Campaigns service-linked role not found after onboarding',\n    );\n  }\n  return arn;\n};\n\n/**\n * Associate the (created) Customer Profiles domain with the Connect instance's\n * Outbound Campaigns v2 so Connect Journeys can target the domain's profiles:\n *   1. connectcampaignsv2:PutConnectInstanceIntegration — binds the domain ARN.\n *   2. customer-profiles:PutIntegration — the reciprocal binding, using the\n *      campaigns service-linked role.\n * Succeeds on an EMPTY domain: `objectTypeNames` is a label/routing map to\n * BUILT-IN templates, so no object types need pre-creating.\n */\nexport const associateDomain = async (\n  clients: {\n    campaigns: ConnectCampaignsV2Client;\n    profiles: CustomerProfilesClient;\n    iam: IAMClient;\n  },\n  args: {\n    connectInstanceId: string;\n    domainName: string;\n    roleArn: string;\n    account: string;\n    region: string;\n  },\n): Promise<void> => {\n  const { campaigns, profiles } = clients;\n  const { connectInstanceId, domainName, roleArn, account, region } = args;\n  const domainArn = domainArnOf(account, region, domainName);\n\n  await campaigns.send(\n    new PutConnectInstanceIntegrationCommand({\n      connectInstanceId,\n      integrationConfig: {\n        customerProfiles: { domainArn, objectTypeNames },\n      },\n    }),\n  );\n  console.log('[campaign-assoc] connect instance integration created', {\n    connectInstanceId,\n    domainArn,\n  });\n\n  await profiles.send(\n    new PutIntegrationCommand({\n      DomainName: domainName,\n      Uri: campaignsInstanceArnOf(account, region, connectInstanceId),\n      ObjectTypeNames: objectTypeNames,\n      RoleArn: roleArn,\n    }),\n  );\n  console.log('[campaign-assoc] customer profiles integration created', {\n    domainName,\n    connectInstanceId,\n  });\n};\n\n/**\n * Best-effort reverse of {@link associateDomain} on stack teardown. Each step is\n * idempotent and swallows errors (logged) so a missing / already-removed\n * integration — e.g. when CloudFormation deleted the parent instance / domain\n * FIRST — NEVER fails teardown. Reverses everything onCreate did:\n *   1. connectcampaignsv2:DeleteConnectInstanceIntegration (campaigns -> domain)\n *   2. customer-profiles:DeleteIntegration (domain -> campaigns)\n *   3. connectcampaignsv2:DeleteInstanceOnboardingJob (offboard from Campaigns v2)\n *\n * The `AWSServiceRoleForConnectCampaigns_*` service-linked role is deliberately\n * NOT deleted: it is account-wide, shared across ALL Connect instances /\n * campaigns in the account, free, and harmless — deleting it could break other\n * instances still onboarded to Outbound Campaigns.\n */\nexport const disassociateDomain = async (\n  clients: {\n    campaigns: ConnectCampaignsV2Client;\n    profiles: CustomerProfilesClient;\n  },\n  args: {\n    connectInstanceId: string;\n    domainName: string;\n    account: string;\n    region: string;\n  },\n): Promise<void> => {\n  const { campaigns, profiles } = clients;\n  const { connectInstanceId, domainName, account, region } = args;\n\n  await bestEffort('connect instance integration delete', () =>\n    campaigns.send(\n      new DeleteConnectInstanceIntegrationCommand({\n        connectInstanceId,\n        integrationIdentifier: {\n          customerProfiles: {\n            domainArn: domainArnOf(account, region, domainName),\n          },\n        },\n      }),\n    ),\n  );\n\n  await bestEffort('customer profiles integration delete', () =>\n    profiles.send(\n      new DeleteIntegrationCommand({\n        DomainName: domainName,\n        Uri: campaignsInstanceArnOf(account, region, connectInstanceId),\n      }),\n    ),\n  );\n\n  await bestEffort('instance offboarding', () =>\n    campaigns.send(\n      new DeleteInstanceOnboardingJobCommand({ connectInstanceId }),\n    ),\n  );\n};\n\n/**\n * Run a teardown step, swallowing (and logging) any error so a partial /\n * already-removed resource never fails CloudFormation teardown.\n */\nconst bestEffort = async (\n  label: string,\n  fn: () => Promise<unknown>,\n): Promise<void> => {\n  try {\n    await fn();\n    console.log(`[campaign-assoc] ${label} ok`);\n  } catch (err) {\n    console.warn(`[campaign-assoc] ${label} skipped`, {\n      error: (err as { name?: string })?.name ?? 'unknown',\n    });\n  }\n};\n"]}

package/lib/lambda/campaign-association/onboarding.d.ts

@@ -0,0 +1,25 @@
+import { ConnectCampaignsV2Client } from '@aws-sdk/client-connectcampaignsv2';
+/**
+ * Onboard an Amazon Connect instance to Outbound Campaigns v2 and wait until the
+ * onboarding job reaches SUCCEEDED.
+ *
+ * StartInstanceOnboardingJob (with encryption disabled) auto-creates the
+ * `AWSServiceRoleForConnectCampaigns_*` service-linked role, then the job runs
+ * asynchronously (~20s). We poll GetInstanceOnboardingJobStatus with bounded,
+ * exponentially-backed-off retries (capped ~2min) until it SUCCEEDS.
+ *
+ * Idempotent: if the instance is already onboarded (StartInstanceOnboardingJob
+ * conflicts or the status is already SUCCEEDED / absent), this resolves without
+ * error. Throws only on an explicit FAILED status or if the job never succeeds
+ * within the polling budget.
+ */
+export declare const ensureInstanceOnboarded: (client: ConnectCampaignsV2Client, opts: {
+    connectInstanceId: string;
+    /** Injected in tests to avoid real delays. Defaults to real setTimeout. */
+    sleepFn?: (ms: number) => Promise<void>;
+    /** Max polling attempts. Default 24 (~2min with capped backoff). */
+    maxAttempts?: number;
+    /** Base backoff in ms. Default 2000. */
+    baseDelayMs?: number;
+}) => Promise<void>;
+//# sourceMappingURL=onboarding.d.ts.map

package/lib/lambda/campaign-association/onboarding.js

@@ -0,0 +1,74 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { GetInstanceOnboardingJobStatusCommand, StartInstanceOnboardingJobCommand, } from '@aws-sdk/client-connectcampaignsv2';
+/** Terminal + in-flight onboarding job statuses reported by the service. */
+const STATUS_SUCCEEDED = 'SUCCEEDED';
+const STATUS_FAILED = 'FAILED';
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * Names that, when thrown by StartInstanceOnboardingJob, indicate the instance
+ * is ALREADY onboarded to Outbound Campaigns v2. Treated as success so the
+ * custom resource is idempotent across stack updates / retried deployments.
+ */
+const isAlreadyOnboardedError = (err) => {
+    const name = err?.name ?? '';
+    return name === 'ConflictException' || name === 'ResourceConflictException';
+};
+/**
+ * Onboard an Amazon Connect instance to Outbound Campaigns v2 and wait until the
+ * onboarding job reaches SUCCEEDED.
+ *
+ * StartInstanceOnboardingJob (with encryption disabled) auto-creates the
+ * `AWSServiceRoleForConnectCampaigns_*` service-linked role, then the job runs
+ * asynchronously (~20s). We poll GetInstanceOnboardingJobStatus with bounded,
+ * exponentially-backed-off retries (capped ~2min) until it SUCCEEDS.
+ *
+ * Idempotent: if the instance is already onboarded (StartInstanceOnboardingJob
+ * conflicts or the status is already SUCCEEDED / absent), this resolves without
+ * error. Throws only on an explicit FAILED status or if the job never succeeds
+ * within the polling budget.
+ */
+export const ensureInstanceOnboarded = async (client, opts) => {
+    const { connectInstanceId, sleepFn = sleep, maxAttempts = 24, baseDelayMs = 2000, } = opts;
+    try {
+        await client.send(new StartInstanceOnboardingJobCommand({
+            connectInstanceId,
+            encryptionConfig: { enabled: false },
+        }));
+        console.log('[campaign-assoc] onboarding job started', {
+            connectInstanceId,
+        });
+    }
+    catch (err) {
+        if (isAlreadyOnboardedError(err)) {
+            console.log('[campaign-assoc] instance already onboarded (start conflict)', {
+                connectInstanceId,
+            });
+            return;
+        }
+        throw err;
+    }
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        const { connectInstanceOnboardingJobStatus } = await client.send(new GetInstanceOnboardingJobStatusCommand({ connectInstanceId }));
+        const status = connectInstanceOnboardingJobStatus?.status;
+        const failureCode = connectInstanceOnboardingJobStatus?.failureCode;
+        console.log('[campaign-assoc] onboarding status', {
+            connectInstanceId,
+            status: status ?? 'NONE',
+            failureCode: failureCode ?? 'NONE',
+            attempt,
+        });
+        if (status === STATUS_SUCCEEDED || status === undefined) {
+            // SUCCEEDED, or no job present (already-onboarded steady state).
+            return;
+        }
+        if (status === STATUS_FAILED) {
+            throw new Error(`Instance onboarding to Outbound Campaigns FAILED for ${connectInstanceId}` +
+                (failureCode ? ` (failureCode: ${failureCode})` : ''));
+        }
+        const delay = Math.min(baseDelayMs * 2 ** attempt, 10000);
+        await sleepFn(delay);
+    }
+    throw new Error(`Instance onboarding did not reach SUCCEEDED within the polling budget for ${connectInstanceId}`);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"onboarding.js","sourceRoot":"","sources":["../../../src/lambda/campaign-association/onboarding.ts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,sCAAsC;AAEtC,OAAO,EAEL,qCAAqC,EACrC,iCAAiC,GAClC,MAAM,oCAAoC,CAAC;AAE5C,4EAA4E;AAC5E,MAAM,gBAAgB,GAAG,WAAW,CAAC;AACrC,MAAM,aAAa,GAAG,QAAQ,CAAC;AAE/B,MAAM,KAAK,GAAG,CAAC,EAAU,EAAiB,EAAE,CAC1C,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;AAEpD;;;;GAIG;AACH,MAAM,uBAAuB,GAAG,CAAC,GAAY,EAAW,EAAE;IACxD,MAAM,IAAI,GAAI,GAAyB,EAAE,IAAI,IAAI,EAAE,CAAC;IACpD,OAAO,IAAI,KAAK,mBAAmB,IAAI,IAAI,KAAK,2BAA2B,CAAC;AAC9E,CAAC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,KAAK,EAC1C,MAAgC,EAChC,IAQC,EACc,EAAE;IACjB,MAAM,EACJ,iBAAiB,EACjB,OAAO,GAAG,KAAK,EACf,WAAW,GAAG,EAAE,EAChB,WAAW,GAAG,IAAI,GACnB,GAAG,IAAI,CAAC;IAET,IAAI,CAAC;QACH,MAAM,MAAM,CAAC,IAAI,CACf,IAAI,iCAAiC,CAAC;YACpC,iBAAiB;YACjB,gBAAgB,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE;SACrC,CAAC,CACH,CAAC;QACF,OAAO,CAAC,GAAG,CAAC,yCAAyC,EAAE;YACrD,iBAAiB;SAClB,CAAC,CAAC;IACL,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,IAAI,uBAAuB,CAAC,GAAG,CAAC,EAAE,CAAC;YACjC,OAAO,CAAC,GAAG,CACT,8DAA8D,EAC9D;gBACE,iBAAiB;aAClB,CACF,CAAC;YACF,OAAO;QACT,CAAC;QACD,MAAM,GAAG,CAAC;IACZ,CAAC;IAED,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,GAAG,WAAW,EAAE,OAAO,EAAE,EAAE,CAAC;QACvD,MAAM,EAAE,kCAAkC,EAAE,GAAG,MAAM,MAAM,CAAC,IAAI,CAC9D,IAAI,qCAAqC,CAAC,EAAE,iBAAiB,EAAE,CAAC,CACjE,CAAC;QACF,MAAM,MAAM,GAAG,kCAAkC,EAAE,MAAM,CAAC;QAC1D,MAAM,WAAW,GAAG,kCAAkC,EAAE,WAAW,CAAC;QACpE,OAAO,CAAC,GAAG,CAAC,oCAAoC,EAAE;YAChD,iBAAiB;YACjB,MAAM,EAAE,MAAM,IAAI,MAAM;YACxB,WAAW,EAAE,WAAW,IAAI,MAAM;YAClC,OAAO;SACR,CAAC,CAAC;QAEH,IAAI,MAAM,KAAK,gBAAgB,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YACxD,iEAAiE;YACjE,OAAO;QACT,CAAC;QACD,IAAI,MAAM,KAAK,aAAa,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CACb,wDAAwD,iBAAiB,EAAE;gBACzE,CAAC,WAAW,CAAC,CAAC,CAAC,kBAAkB,WAAW,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CACxD,CAAC;QACJ,CAAC;QAED,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,WAAW,GAAG,CAAC,IAAI,OAAO,EAAE,KAAK,CAAC,CAAC;QAC1D,MAAM,OAAO,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC;IAED,MAAM,IAAI,KAAK,CACb,6EAA6E,iBAAiB,EAAE,CACjG,CAAC;AACJ,CAAC,CAAC","sourcesContent":["// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// SPDX-License-Identifier: Apache-2.0\n\nimport {\n  ConnectCampaignsV2Client,\n  GetInstanceOnboardingJobStatusCommand,\n  StartInstanceOnboardingJobCommand,\n} from '@aws-sdk/client-connectcampaignsv2';\n\n/** Terminal + in-flight onboarding job statuses reported by the service. */\nconst STATUS_SUCCEEDED = 'SUCCEEDED';\nconst STATUS_FAILED = 'FAILED';\n\nconst sleep = (ms: number): Promise<void> =>\n  new Promise((resolve) => setTimeout(resolve, ms));\n\n/**\n * Names that, when thrown by StartInstanceOnboardingJob, indicate the instance\n * is ALREADY onboarded to Outbound Campaigns v2. Treated as success so the\n * custom resource is idempotent across stack updates / retried deployments.\n */\nconst isAlreadyOnboardedError = (err: unknown): boolean => {\n  const name = (err as { name?: string })?.name ?? '';\n  return name === 'ConflictException' || name === 'ResourceConflictException';\n};\n\n/**\n * Onboard an Amazon Connect instance to Outbound Campaigns v2 and wait until the\n * onboarding job reaches SUCCEEDED.\n *\n * StartInstanceOnboardingJob (with encryption disabled) auto-creates the\n * `AWSServiceRoleForConnectCampaigns_*` service-linked role, then the job runs\n * asynchronously (~20s). We poll GetInstanceOnboardingJobStatus with bounded,\n * exponentially-backed-off retries (capped ~2min) until it SUCCEEDS.\n *\n * Idempotent: if the instance is already onboarded (StartInstanceOnboardingJob\n * conflicts or the status is already SUCCEEDED / absent), this resolves without\n * error. Throws only on an explicit FAILED status or if the job never succeeds\n * within the polling budget.\n */\nexport const ensureInstanceOnboarded = async (\n  client: ConnectCampaignsV2Client,\n  opts: {\n    connectInstanceId: string;\n    /** Injected in tests to avoid real delays. Defaults to real setTimeout. */\n    sleepFn?: (ms: number) => Promise<void>;\n    /** Max polling attempts. Default 24 (~2min with capped backoff). */\n    maxAttempts?: number;\n    /** Base backoff in ms. Default 2000. */\n    baseDelayMs?: number;\n  },\n): Promise<void> => {\n  const {\n    connectInstanceId,\n    sleepFn = sleep,\n    maxAttempts = 24,\n    baseDelayMs = 2000,\n  } = opts;\n\n  try {\n    await client.send(\n      new StartInstanceOnboardingJobCommand({\n        connectInstanceId,\n        encryptionConfig: { enabled: false },\n      }),\n    );\n    console.log('[campaign-assoc] onboarding job started', {\n      connectInstanceId,\n    });\n  } catch (err) {\n    if (isAlreadyOnboardedError(err)) {\n      console.log(\n        '[campaign-assoc] instance already onboarded (start conflict)',\n        {\n          connectInstanceId,\n        },\n      );\n      return;\n    }\n    throw err;\n  }\n\n  for (let attempt = 0; attempt < maxAttempts; attempt++) {\n    const { connectInstanceOnboardingJobStatus } = await client.send(\n      new GetInstanceOnboardingJobStatusCommand({ connectInstanceId }),\n    );\n    const status = connectInstanceOnboardingJobStatus?.status;\n    const failureCode = connectInstanceOnboardingJobStatus?.failureCode;\n    console.log('[campaign-assoc] onboarding status', {\n      connectInstanceId,\n      status: status ?? 'NONE',\n      failureCode: failureCode ?? 'NONE',\n      attempt,\n    });\n\n    if (status === STATUS_SUCCEEDED || status === undefined) {\n      // SUCCEEDED, or no job present (already-onboarded steady state).\n      return;\n    }\n    if (status === STATUS_FAILED) {\n      throw new Error(\n        `Instance onboarding to Outbound Campaigns FAILED for ${connectInstanceId}` +\n          (failureCode ? ` (failureCode: ${failureCode})` : ''),\n      );\n    }\n\n    const delay = Math.min(baseDelayMs * 2 ** attempt, 10000);\n    await sleepFn(delay);\n  }\n\n  throw new Error(\n    `Instance onboarding did not reach SUCCEEDED within the polling budget for ${connectInstanceId}`,\n  );\n};\n"]}

package/lib/lambda/identify/device_resolver.d.ts

@@ -0,0 +1,18 @@
+import { CustomerProfilesClient } from '@aws-sdk/client-customer-profiles';
+/**
+ * Read back the IMMUTABLE `createdAt` of the existing AmplifyDevice object for
+ * `deviceId` under the resolved profile, so a subsequent PutProfileObject (which
+ * REPLACES the object for that key) can preserve the original first-registration
+ * time while refreshing `updatedAt`.
+ *
+ * Pages through the profile's device objects and matches by `deviceId` (the
+ * UNIQUE object key). Returns the stored `createdAt` when a prior object exists,
+ * otherwise `undefined` so the caller sets a fresh `createdAt = now`.
+ *
+ * Best-effort and NEVER throws: any failure — a not-yet-propagated profile
+ * (SearchProfiles / ListProfileObjects are eventually consistent), a transient
+ * service error, or a permissions gap — simply yields `undefined` so the caller
+ * re-seeds `createdAt` and device registration stays resilient.
+ */
+export declare const findExistingDeviceCreatedAt: (profiles: CustomerProfilesClient, domainName: string, profileId: string, deviceId: string) => Promise<string | undefined>;
+//# sourceMappingURL=device_resolver.d.ts.map

package/lib/lambda/identify/device_resolver.js

@@ -0,0 +1,56 @@
+import { ListProfileObjectsCommand, } from '@aws-sdk/client-customer-profiles';
+import { OBJECT_TYPE_DEVICE } from '../../constants.js';
+import { withTransientRetry } from '../shared/retry.js';
+/**
+ * Read back the IMMUTABLE `createdAt` of the existing AmplifyDevice object for
+ * `deviceId` under the resolved profile, so a subsequent PutProfileObject (which
+ * REPLACES the object for that key) can preserve the original first-registration
+ * time while refreshing `updatedAt`.
+ *
+ * Pages through the profile's device objects and matches by `deviceId` (the
+ * UNIQUE object key). Returns the stored `createdAt` when a prior object exists,
+ * otherwise `undefined` so the caller sets a fresh `createdAt = now`.
+ *
+ * Best-effort and NEVER throws: any failure — a not-yet-propagated profile
+ * (SearchProfiles / ListProfileObjects are eventually consistent), a transient
+ * service error, or a permissions gap — simply yields `undefined` so the caller
+ * re-seeds `createdAt` and device registration stays resilient.
+ */
+export const findExistingDeviceCreatedAt = async (profiles, domainName, profileId, deviceId) => {
+    try {
+        let nextToken;
+        do {
+            const res = await withTransientRetry(() => profiles.send(new ListProfileObjectsCommand({
+                DomainName: domainName,
+                ObjectTypeName: OBJECT_TYPE_DEVICE,
+                ProfileId: profileId,
+                NextToken: nextToken,
+            })));
+            for (const item of res.Items ?? []) {
+                if (!item.Object) {
+                    continue;
+                }
+                try {
+                    const parsed = JSON.parse(item.Object);
+                    if (parsed.deviceId === deviceId &&
+                        typeof parsed.createdAt === 'string' &&
+                        parsed.createdAt.length > 0) {
+                        return parsed.createdAt;
+                    }
+                }
+                catch {
+                    // Ignore a malformed stored object; treat as no prior createdAt.
+                    continue;
+                }
+            }
+            nextToken = res.NextToken;
+        } while (nextToken);
+    }
+    catch {
+        // Best-effort: ListProfileObjects unavailable / errored; the caller
+        // re-seeds createdAt = now rather than failing device registration.
+        return undefined;
+    }
+    return undefined;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/lambda/identify/handler.d.ts

@@ -0,0 +1,17 @@
+import type { APIGatewayProxyStructuredResultV2 } from 'aws-lambda';
+import { IdentifyEvent } from './principal.js';
+/**
+ * HTTP API handler for the identify-user routes. Serves BOTH:
+ *   - `POST /identify-user`        — authed (Cognito user-pool JWT authorizer,
+ *     payload format 2.0). Identity = verified `sub`.
+ *   - `POST /identify-user-guest`  — guest (IAM/SigV4 authorization, payload
+ *     format 1.0). Identity = verified Cognito Identity Pool `cognitoIdentityId`
+ *     of an UNAUTHENTICATED identity.
+ *
+ * The verified {@link Principal} abstracts the two modes; the profile
+ * find-or-create + device upsert + attribute write are identity-agnostic. On an
+ * authed call carrying `options.previousGuestIdentityId`, the prior guest
+ * profile (and its devices) is folded into the authed profile via MergeProfiles.
+ */
+export declare const handler: (event: IdentifyEvent) => Promise<APIGatewayProxyStructuredResultV2>;
+//# sourceMappingURL=handler.d.ts.map

package/lib/lambda/identify/handler.js

@@ -0,0 +1,124 @@
+import { CustomerProfilesClient, PutProfileObjectCommand, UpdateProfileCommand, } from '@aws-sdk/client-customer-profiles';
+import { validateBody } from './validation.js';
+import { buildDeviceObject, buildProfileUpdate, hasDeviceData, } from './mapping.js';
+import { resolveOrCreateProfile } from './profile_resolver.js';
+import { findExistingDeviceCreatedAt } from './device_resolver.js';
+import { mergeGuestIntoAuthed } from './merge_resolver.js';
+import { resolvePrincipal } from './principal.js';
+import { withTransientRetry } from '../shared/retry.js';
+import { ENV_DOMAIN_NAME, OBJECT_TYPE_DEVICE } from '../../constants.js';
+/**
+ * Module-level client so warm invocations reuse the connection pool. Region is
+ * resolved from the standard AWS_REGION Lambda environment variable.
+ */
+const profiles = new CustomerProfilesClient({});
+const response = (statusCode, body) => ({
+    statusCode,
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body),
+});
+/**
+ * HTTP API handler for the identify-user routes. Serves BOTH:
+ *   - `POST /identify-user`        — authed (Cognito user-pool JWT authorizer,
+ *     payload format 2.0). Identity = verified `sub`.
+ *   - `POST /identify-user-guest`  — guest (IAM/SigV4 authorization, payload
+ *     format 1.0). Identity = verified Cognito Identity Pool `cognitoIdentityId`
+ *     of an UNAUTHENTICATED identity.
+ *
+ * The verified {@link Principal} abstracts the two modes; the profile
+ * find-or-create + device upsert + attribute write are identity-agnostic. On an
+ * authed call carrying `options.previousGuestIdentityId`, the prior guest
+ * profile (and its devices) is folded into the authed profile via MergeProfiles.
+ */
+export const handler = async (event) => {
+    const domainName = process.env[ENV_DOMAIN_NAME];
+    if (!domainName) {
+        console.error(`Missing required env var ${ENV_DOMAIN_NAME}`);
+        return response(500, { error: 'Server misconfiguration' });
+    }
+    const principal = resolvePrincipal(event);
+    if (!principal) {
+        return response(401, {
+            error: 'Unauthorized: missing or invalid verified caller identity',
+        });
+    }
+    let parsed;
+    try {
+        parsed = event.body ? JSON.parse(event.body) : undefined;
+    }
+    catch {
+        return response(400, { error: 'Invalid JSON request body' });
+    }
+    const validation = validateBody(parsed);
+    if (!validation.ok || !validation.value) {
+        return response(400, { error: validation.error ?? 'Invalid request' });
+    }
+    const request = validation.value;
+    try {
+        // 1) Resolve (or create + key) the profile bound to the verified caller.
+        //    Isolated behind resolveOrCreateProfile so the identity-resolution
+        //    strategy (authed sub vs guest identityId) is a single seam.
+        const { profileId } = await resolveOrCreateProfile(profiles, domainName, principal);
+        // 2) Register / update the device object (keyed by stable deviceId) only
+        //    when device data is present. Token refreshes upsert in place: because
+        //    PutProfileObject REPLACES the object for a deviceId, read back the
+        //    prior object first to preserve its immutable `createdAt`.
+        if (hasDeviceData(request)) {
+            const deviceId = request.options.deviceId;
+            const existingCreatedAt = await findExistingDeviceCreatedAt(profiles, domainName, profileId, deviceId);
+            const deviceObject = buildDeviceObject(principal, request, existingCreatedAt);
+            await withTransientRetry(() => profiles.send(new PutProfileObjectCommand({
+                DomainName: domainName,
+                ObjectTypeName: OBJECT_TYPE_DEVICE,
+                Object: JSON.stringify(deviceObject),
+            })));
+        }
+        // 3) Set user-level / targeting attributes (incl. promoted hasGCM/hasAPNS)
+        //    on the resolved profile.
+        const update = buildProfileUpdate(principal, request);
+        await withTransientRetry(() => profiles.send(new UpdateProfileCommand({
+            DomainName: domainName,
+            ProfileId: profileId,
+            EmailAddress: update.emailAddress,
+            FirstName: update.firstName,
+            LastName: update.lastName,
+            Address: update.address
+                ? {
+                    City: update.address.city,
+                    Country: update.address.country,
+                    PostalCode: update.address.postalCode,
+                    Province: update.address.province,
+                }
+                : undefined,
+            Attributes: update.attributes,
+        })));
+        // 4) Merge-on-sign-in: an AUTHENTICATED caller that carries its prior guest
+        //    identityId folds the guest profile (+ its devices) into this authed
+        //    profile via MergeProfiles. Guests never trigger a merge. Best-effort:
+        //    a merge failure is logged but does not fail the identify result, which
+        //    already succeeded above.
+        const guestIdentityId = request.options?.previousGuestIdentityId;
+        if (principal.kind === 'authed' && guestIdentityId) {
+            try {
+                const outcome = await mergeGuestIntoAuthed(profiles, domainName, guestIdentityId, profileId);
+                console.log('[identify] guestMerge', JSON.stringify({ merged: outcome.merged }));
+            }
+            catch (mergeErr) {
+                const name = mergeErr instanceof Error ? mergeErr.name : 'UnknownError';
+                console.error('[identify] guestMergeError', JSON.stringify({ name }));
+            }
+        }
+        return response(200, { status: 'ok' });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : 'unknown error';
+        // Log only the error name (and HTTP status when present) — never the full
+        // error object, whose stack / request input can carry customer content.
+        const name = err instanceof Error ? err.name : 'UnknownError';
+        const statusCode = err
+            ?.$metadata?.httpStatusCode;
+        console.error('[identify] customerProfilesError', JSON.stringify({ name, statusCode }));
+        return response(500, { error: `Customer Profiles error: ${message}` });
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"handler.js","sourceRoot":"","sources":["../../../src/lambda/identify/handler.ts"],"names":[],"mappings":"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","sourcesContent":["import type { APIGatewayProxyStructuredResultV2 } from 'aws-lambda';\nimport {\n  CustomerProfilesClient,\n  PutProfileObjectCommand,\n  UpdateProfileCommand,\n} from '@aws-sdk/client-customer-profiles';\n\nimport { validateBody } from './validation.js';\nimport {\n  buildDeviceObject,\n  buildProfileUpdate,\n  hasDeviceData,\n} from './mapping.js';\nimport { resolveOrCreateProfile } from './profile_resolver.js';\nimport { findExistingDeviceCreatedAt } from './device_resolver.js';\nimport { mergeGuestIntoAuthed } from './merge_resolver.js';\nimport { IdentifyEvent, resolvePrincipal } from './principal.js';\nimport { withTransientRetry } from '../shared/retry.js';\nimport { ENV_DOMAIN_NAME, OBJECT_TYPE_DEVICE } from '../../constants.js';\nimport { ErrorResponse, SuccessResponse } from './types.js';\n\n/**\n * Module-level client so warm invocations reuse the connection pool. Region is\n * resolved from the standard AWS_REGION Lambda environment variable.\n */\nconst profiles = new CustomerProfilesClient({});\n\nconst response = (\n  statusCode: number,\n  body: SuccessResponse | ErrorResponse,\n): APIGatewayProxyStructuredResultV2 => ({\n  statusCode,\n  headers: { 'content-type': 'application/json' },\n  body: JSON.stringify(body),\n});\n\n/**\n * HTTP API handler for the identify-user routes. Serves BOTH:\n *   - `POST /identify-user`        — authed (Cognito user-pool JWT authorizer,\n *     payload format 2.0). Identity = verified `sub`.\n *   - `POST /identify-user-guest`  — guest (IAM/SigV4 authorization, payload\n *     format 1.0). Identity = verified Cognito Identity Pool `cognitoIdentityId`\n *     of an UNAUTHENTICATED identity.\n *\n * The verified {@link Principal} abstracts the two modes; the profile\n * find-or-create + device upsert + attribute write are identity-agnostic. On an\n * authed call carrying `options.previousGuestIdentityId`, the prior guest\n * profile (and its devices) is folded into the authed profile via MergeProfiles.\n */\nexport const handler = async (\n  event: IdentifyEvent,\n): Promise<APIGatewayProxyStructuredResultV2> => {\n  const domainName = process.env[ENV_DOMAIN_NAME];\n  if (!domainName) {\n    console.error(`Missing required env var ${ENV_DOMAIN_NAME}`);\n    return response(500, { error: 'Server misconfiguration' });\n  }\n\n  const principal = resolvePrincipal(event);\n  if (!principal) {\n    return response(401, {\n      error: 'Unauthorized: missing or invalid verified caller identity',\n    });\n  }\n\n  let parsed: unknown;\n  try {\n    parsed = event.body ? JSON.parse(event.body) : undefined;\n  } catch {\n    return response(400, { error: 'Invalid JSON request body' });\n  }\n\n  const validation = validateBody(parsed);\n  if (!validation.ok || !validation.value) {\n    return response(400, { error: validation.error ?? 'Invalid request' });\n  }\n  const request = validation.value;\n\n  try {\n    // 1) Resolve (or create + key) the profile bound to the verified caller.\n    //    Isolated behind resolveOrCreateProfile so the identity-resolution\n    //    strategy (authed sub vs guest identityId) is a single seam.\n    const { profileId } = await resolveOrCreateProfile(\n      profiles,\n      domainName,\n      principal,\n    );\n\n    // 2) Register / update the device object (keyed by stable deviceId) only\n    //    when device data is present. Token refreshes upsert in place: because\n    //    PutProfileObject REPLACES the object for a deviceId, read back the\n    //    prior object first to preserve its immutable `createdAt`.\n    if (hasDeviceData(request)) {\n      const deviceId = request.options!.deviceId!;\n      const existingCreatedAt = await findExistingDeviceCreatedAt(\n        profiles,\n        domainName,\n        profileId,\n        deviceId,\n      );\n      const deviceObject = buildDeviceObject(\n        principal,\n        request,\n        existingCreatedAt,\n      );\n      await withTransientRetry(() =>\n        profiles.send(\n          new PutProfileObjectCommand({\n            DomainName: domainName,\n            ObjectTypeName: OBJECT_TYPE_DEVICE,\n            Object: JSON.stringify(deviceObject),\n          }),\n        ),\n      );\n    }\n\n    // 3) Set user-level / targeting attributes (incl. promoted hasGCM/hasAPNS)\n    //    on the resolved profile.\n    const update = buildProfileUpdate(principal, request);\n    await withTransientRetry(() =>\n      profiles.send(\n        new UpdateProfileCommand({\n          DomainName: domainName,\n          ProfileId: profileId,\n          EmailAddress: update.emailAddress,\n          FirstName: update.firstName,\n          LastName: update.lastName,\n          Address: update.address\n            ? {\n                City: update.address.city,\n                Country: update.address.country,\n                PostalCode: update.address.postalCode,\n                Province: update.address.province,\n              }\n            : undefined,\n          Attributes: update.attributes,\n        }),\n      ),\n    );\n\n    // 4) Merge-on-sign-in: an AUTHENTICATED caller that carries its prior guest\n    //    identityId folds the guest profile (+ its devices) into this authed\n    //    profile via MergeProfiles. Guests never trigger a merge. Best-effort:\n    //    a merge failure is logged but does not fail the identify result, which\n    //    already succeeded above.\n    const guestIdentityId = request.options?.previousGuestIdentityId;\n    if (principal.kind === 'authed' && guestIdentityId) {\n      try {\n        const outcome = await mergeGuestIntoAuthed(\n          profiles,\n          domainName,\n          guestIdentityId,\n          profileId,\n        );\n        console.log(\n          '[identify] guestMerge',\n          JSON.stringify({ merged: outcome.merged }),\n        );\n      } catch (mergeErr) {\n        const name = mergeErr instanceof Error ? mergeErr.name : 'UnknownError';\n        console.error('[identify] guestMergeError', JSON.stringify({ name }));\n      }\n    }\n\n    return response(200, { status: 'ok' });\n  } catch (err) {\n    const message = err instanceof Error ? err.message : 'unknown error';\n    // Log only the error name (and HTTP status when present) — never the full\n    // error object, whose stack / request input can carry customer content.\n    const name = err instanceof Error ? err.name : 'UnknownError';\n    const statusCode = (err as { $metadata?: { httpStatusCode?: number } })\n      ?.$metadata?.httpStatusCode;\n    console.error(\n      '[identify] customerProfilesError',\n      JSON.stringify({ name, statusCode }),\n    );\n    return response(500, { error: `Customer Profiles error: ${message}` });\n  }\n};\n"]}

package/lib/lambda/identify/mapping.d.ts

@@ -0,0 +1,61 @@
+import { ChannelType, IdentifyUserRequest } from './types.js';
+import { Principal } from './principal.js';
+/** A standard Customer Profiles address (subset used by this backend). */
+export type ProfileAddress = {
+    city?: string;
+    country?: string;
+    postalCode?: string;
+    province?: string;
+};
+/** Person data mapped to UpdateProfile standard fields + Attributes map. */
+export type ProfileUpdate = {
+    emailAddress?: string;
+    firstName?: string;
+    lastName?: string;
+    address?: ProfileAddress;
+    attributes: Record<string, string>;
+};
+/**
+ * Flatten a multi-value attribute into a single string that fits within the
+ * Customer Profiles attribute-value limit.
+ *
+ * - Zero values -> empty string.
+ * - Exactly one value -> that element verbatim.
+ * - More than one value -> JSON.stringify of the array (preserves all values).
+ * The result is truncated to {@link MAX_ATTRIBUTE_LENGTH} characters.
+ */
+export declare const flatten: (values: string[]) => string;
+/** Which promoted targeting attribute a channel type activates. */
+export declare const targetingFlagsForChannel: (channelType: ChannelType | undefined) => {
+    hasGCM?: string;
+    hasAPNS?: string;
+};
+/** True when the request carries enough data to register/update a device. */
+export declare const hasDeviceData: (req: IdentifyUserRequest) => boolean;
+/**
+ * Build the UpdateProfile payload (standard fields + Attributes map) for the
+ * profile identified by the verified {@link Principal} (authed `sub` or guest
+ * `cognitoIdentityId`).
+ *
+ * SECURITY: `principal.value` comes from an authorizer-verified source (JWT
+ * claims or the IAM/Cognito identity). The client-supplied `userId` is stored
+ * only as the `appUserId` attribute — never the identity.
+ */
+export declare const buildProfileUpdate: (principal: Principal, req: IdentifyUserRequest) => ProfileUpdate;
+/**
+ * Build the `_source.*` payload for the AmplifyDevice object type.
+ *
+ * Keyed UNIQUELY by the stable `deviceId`; `deviceToken` (options.address) is a
+ * mutable field so token refreshes upsert the same object in place. Carries the
+ * verified identity field (`cognitoSub` for authed, `cognitoIdentityId` for
+ * guest) as the PROFILE-resolution key so the device merges into the profile
+ * bound to that {@link Principal}.
+ *
+ * `platform` / `appVersion` come from the options, falling back to the
+ * `userProfile.demographic` equivalents. `updatedAt` is server-set on every
+ * write; `createdAt` is the IMMUTABLE first-registration time — the caller
+ * passes the value read back from the existing device object (if any) so it is
+ * preserved across PutProfileObject replacements, otherwise it defaults to now.
+ */
+export declare const buildDeviceObject: (principal: Principal, req: IdentifyUserRequest, existingCreatedAt?: string) => Record<string, string>;
+//# sourceMappingURL=mapping.d.ts.map