@mpgd/game-services 0.28.1 → 0.29.0

package/dist/notifications/service.js

@@ -1,4 +1,4 @@
-import { assertNotificationConsentRecord, assertNotificationDeployment, assertNotificationEndpointRegistration, assertRecordNotificationNoticeInput, createNotificationNoticeIdempotencyKey, createNotificationReminderIdempotencyKey, evaluateNotificationDelivery, evaluateNotificationReminderConsent, fillNotificationTemplate, isNotificationTimestamp, isSameNotificationNotice, isValidNotificationTimeZone, latestNotificationConsent, listNotificationNotices, normalizeNotificationTimestamp, NotificationError, notificationKeyIssue, notificationNoticeCopyIssues, notificationNoticeSendFrom, notificationNoticeTopic, notificationProviderCarriesNotices, notificationReservedKeyPrefix, notificationSendFingerprint, notificationTemplateDataIssue, toSeoulCalendarDate, } from '@mpgd/platform/notifications';
+import { assertNotificationConsentRecord, assertNotificationDeployment, assertNotificationEndpointRegistration, assertRecordNotificationNoticeInput, createNotificationNoticeIdempotencyKey, createNotificationReminderIdempotencyKey, evaluateNotificationDelivery, evaluateNotificationReminderConsent, fillNotificationTemplate, isNotificationTimestamp, isSameNotificationNotice, isValidNotificationTimeZone, latestNotificationConsent, listNotificationNotices, normalizeNotificationTimestamp, NotificationError, notificationKeyIssue, notificationNoticeCopyIssues, notificationNoticeSendFrom, notificationNoticeTopic, notificationProviderCarriesNotices, notificationReservedKeyPrefix, notificationSendFingerprint, notificationShellRenderedAdvertisingTargets, notificationTemplateDataIssue, toSeoulCalendarDate, } from '@mpgd/platform/notifications';
 import { fcmInstallationIdRefusal, notificationExpiredProviderCode, } from './delivery-provider.js';
 import { notificationHistoryRetentionDays, } from './registry.js';
 import { bestNotificationOutcome, formatNotificationInstant, isNotificationRowAbandoned, isNotificationRowDue, notificationAmbiguousReplayHours, notificationSendOutcome, } from './store.js';
@@ -179,12 +179,15 @@ export function createNotificationService(input) {
         }
     };
     // Topics.
+    /**
+     * The catalog targets from which a recipient's topic is read: the target
+     * its registration named while the provider still serves it, else every
+     * target the provider serves, in order.
+     */
+    const candidateTargetsOf = (provider, target) => target !== undefined && provider.targets.includes(target) ? [target] : provider.targets;
     /** The topic as declared for the recipient's target, else for the provider's first target that declares it. */
     const topicFor = (provider, target, topicId, origin) => {
-        const targets = target !== undefined && provider.targets.includes(target)
-            ? [target]
-            : provider.targets;
-        for (const candidate of targets) {
+        for (const candidate of candidateTargetsOf(provider, target)) {
             const topic = catalog.topicsFor(candidate).find((declared) => declared.id === topicId);
             if (topic !== undefined) {
                 // A notice says only its variant of notices.copy.
@@ -206,6 +209,24 @@ export function createNotificationService(input) {
         : [];
     const noticeListed = async (player, notice, at) => (await noticesOf(player, at)).some((listed) => isSameNotificationNotice(listed, notice));
     // Recipients (gate step 2).
+    /**
+     * Whether an endpoint's topic may be read from a target whose pushes need
+     * the shell to render advertising (Android), as `topicFor` picks it: the
+     * named target while the provider serves it, else any target it serves.
+     */
+    const mayNeedShellRendering = (provider, target) => candidateTargetsOf(provider, target)
+        .some((candidate) => notificationShellRenderedAdvertisingTargets.includes(candidate));
+    /**
+     * Whether a device endpoint shows the actions a push carries: where its
+     * topic may come from a target that needs the shell to render advertising
+     * (Android), only when its latest registration said the shell does;
+     * elsewhere (iOS's category) always. Gate step 1 refuses advertising
+     * under `kr` to an endpoint without `true`.
+     */
+    const endpointActionsOf = (provider, endpoint) => ({
+        endpointShowsActions: !mayNeedShellRendering(provider, endpoint.target)
+            || endpoint.address.rendersAdvertising === true,
+    });
     const usable = (endpoint, at) => endpoint.status === 'valid'
         && at - Date.parse(endpoint.lastRegisteredAt) < endpointStaleMs
         && (endpoint.sessionExpiresAt === undefined || Date.parse(endpoint.sessionExpiresAt) > at);
@@ -409,6 +430,7 @@ export function createNotificationService(input) {
                     consent,
                     ...(serverPermission === undefined ? {} : { serverPermission }),
                     ...(recipient.endpoint === undefined ? {} : { endpointPermission: recipient.endpoint.permission }),
+                    ...(recipient.endpoint === undefined ? {} : endpointActionsOf(recipient.provider, recipient.endpoint)),
                     history,
                     at: formatNotificationInstant(at),
                     ...(recipient.timeZone === undefined ? {} : { timeZone: recipient.timeZone }),
@@ -1980,6 +2002,11 @@ export function createNotificationService(input) {
             if (request.target !== undefined && !provider.targets.includes(request.target)) {
                 throw invalidInput(`Provider ${provider.entry.provider} does not serve target ${String(request.target)}.`);
             }
+            // Only a target whose pushes need the shell to render advertising keeps
+            // the claim, so the FCM provider never sends another device (iOS) a
+            // data message it would not show.
+            const rendersAdvertising = address.rendersAdvertising === true
+                && mayNeedShellRendering(provider, request.target);
             await store.putEndpoint({
                 provider: provider.entry.provider,
                 installationId: current.installationId,
@@ -1988,6 +2015,7 @@ export function createNotificationService(input) {
                     kind: address.kind,
                     value: address.value,
                     ...(address.environment === undefined ? {} : { environment: address.environment }),
+                    ...(rendersAdvertising ? { rendersAdvertising: true } : {}),
                 },
                 permission: address.permission,
                 ...(registration.locale === undefined ? {} : { locale: registration.locale }),

package/dist/notifications/store-conformance.js

@@ -65,9 +65,15 @@ export async function runNotificationStoreConformance(createStore) {
         timeZone: 'Asia/Seoul',
         target: 'android',
         sessionExpiresAt: at(86_400_000),
-        address: { kind: 'fcm-token', value: 'tok-1', environment: 'production' },
+        address: {
+            kind: 'fcm-token',
+            value: 'tok-1',
+            environment: 'production',
+            rendersAdvertising: true,
+        },
     }));
     equal(stored.status, 'valid', 'endpoints: a new endpoint is valid');
+    deepEqual((await store.getEndpoint({ provider: 'fcm', installationId: 'i-1' }))?.address, { kind: 'fcm-token', value: 'tok-1', environment: 'production', rendersAdvertising: true }, 'endpoints: the address round-trips, with the shell-rendered advertising claim');
     deepEqual(await store.getEndpoint({ provider: 'fcm', installationId: 'i-1' }), stored, 'endpoints: read back as written');
     // The same address on another installation moves there.
     await store.putEndpoint(endpoint('i-2', 'tok-1'));

package/dist/notifications/store.d.ts

@@ -1,3 +1,4 @@
+import { type PlayerDataErasureInput, type PlayerDataErasureResult } from '../account-deletion.js';
 import { type NotificationConsentRecord, type NotificationDeferralReason, type NotificationDeliveryOutcome, type NotificationNoticeIdentity, type NotificationNoticeVariant, type NotificationPermissionState, type NotificationTemplateData } from '@mpgd/platform/notifications';
 import type { NotificationDeviceAddress } from './delivery-provider.js';
 /**
@@ -417,6 +418,14 @@ export interface InMemoryNotificationStoreState {
 export interface InMemoryNotificationStore extends NotificationStore {
   /** A deep copy of every row, read synchronously. */
   inspect(): InMemoryNotificationStoreState;
+  /**
+  * Account deletion (a `PlayerDataEraser`): removes every row of the player
+  * (consent records, endpoints, platform registrations, notices given,
+  * sends, delivery history, and schedule entries). Nothing is kept: no
+  * notification data is under a legal retention period. The Worker's D1
+  * deployment erases these tables in its own batch.
+  */
+  erasePlayerData(input: PlayerDataErasureInput): Promise<PlayerDataErasureResult>;
 }
 /**
 * A process-local store for tests, conformance runs, and local development.

package/dist/notifications/store.js

@@ -1,3 +1,4 @@
+import { assertPlayerDataErasureInput, } from '../account-deletion.js';
 import { normalizeNotificationTimestamp, } from '@mpgd/platform/notifications';
 export function notificationRowOutcome(row) {
     switch (row.state.status) {
@@ -163,6 +164,46 @@ export function createInMemoryNotificationStore() {
         notice.dueBy,
     ]);
     return {
+        async erasePlayerData(input) {
+            const player = assertPlayerDataErasureInput(input).playerId;
+            let removed = 0;
+            const keep = (rows, belongs) => {
+                let kept = 0;
+                for (const row of rows) {
+                    if (belongs(row)) {
+                        removed += 1;
+                    }
+                    else {
+                        rows[kept] = row;
+                        kept += 1;
+                    }
+                }
+                rows.length = kept;
+            };
+            keep(consent, (row) => row.player === player);
+            keep(endpoints, (endpoint) => endpoint.player === player);
+            keep(noticesGiven, (notice) => notice.player === player);
+            keep(history, (entry) => entry.player === player);
+            for (const [key, registration] of [...platformRegistrations]) {
+                if (registration.player === player) {
+                    platformRegistrations.delete(key);
+                    removed += 1;
+                }
+            }
+            for (const [key, held] of [...sends]) {
+                if (held.send.request.player === player) {
+                    sends.delete(key);
+                    removed += 1;
+                }
+            }
+            for (const [key, held] of [...schedule]) {
+                if (held.entry.player === player) {
+                    schedule.delete(key);
+                    removed += 1;
+                }
+            }
+            return { deleted: removed, retained: 0 };
+        },
         inspect() {
             return copy({
                 consent: consent.map((row) => ({ ...row.record, player: row.player })),

package/dist/operation-results.d.ts

@@ -7,6 +7,13 @@ export interface VerifyPurchaseResponse {
   readonly alreadyProcessed: boolean;
   readonly reason?: string;
   readonly finalization?: PurchaseGrantFinalization;
+  /**
+  * This player's grant comes from a verified restore of a purchase the
+  * store binds to another player (a reinstall or another device): the game
+  * can say the purchase was restored to this device. Present only on a
+  * verified response.
+  */
+  readonly restoredAcrossPlayers?: true;
 }
 export type PurchaseGrantFinalizationAction = 'acknowledge' | 'consume' | 'finish' | 'complete';
 export interface PurchaseGrantFinalization {

package/dist/purchase-sharing.d.ts

@@ -0,0 +1,41 @@
+/**
+* Restore sharing (RFC "Restore sharing"): a guest lives in the device's
+* secure store, so a reinstall, a new device, or a second device on the same
+* store account is a new guest while the store keeps returning the
+* purchase's non-consumable with the buyer's account binding (Google Play
+* `obfuscatedAccountId`, StoreKit `appAccountToken`). Under the `share`
+* policy the backend accepts the store's own verification of a restored
+* non-consumable as the proof of ownership and grants the restoring player
+* its own entitlement, linked to the purchase. Earlier holders keep theirs,
+* up to `maxHolders` players per purchase; a refund or revocation of the
+* purchase revokes every holder. Consumables and subscriptions are never
+* shared.
+*/
+/** How the backend answers a restored non-consumable the store binds to another player. */
+export interface PurchaseRestoreSharingPolicy {
+  /**
+  * `share` grants the restoring player its own entitlement; `refuse`
+  * answers the store's binding mismatch (`GOOGLE_PLAY_ACCOUNT_MISMATCH`,
+  * `APP_STORE_ACCOUNT_TOKEN_MISMATCH`) as before.
+  */
+  readonly mode: 'share' | 'refuse';
+  /**
+  * At most this many players hold one purchase at the same time (the first
+  * grant included; a deleted player's retained record and reversed grants
+  * do not count). A restore past it answers `pending` with
+  * `PURCHASE_HOLDER_LIMIT_REACHED`; no holder is evicted. Defaults to 5.
+  */
+  readonly maxHolders?: number;
+}
+export declare const defaultPurchaseRestoreMaxHolders = 5;
+/** The policy `createGameServicesBackend` uses when none is passed: restores across players are refused. */
+export declare const refusePurchaseRestoreSharing: PurchaseRestoreSharingPolicy;
+/** The reference stack's policy: share, up to the default number of holders. */
+export declare const sharePurchaseRestores: PurchaseRestoreSharingPolicy;
+/** The largest `maxHolders` a policy accepts; a purchase's holders are read one by one. */
+export declare const maxPurchaseRestoreHolders = 100;
+export interface ResolvedPurchaseRestoreSharingPolicy {
+  readonly mode: 'share' | 'refuse';
+  readonly maxHolders: number;
+}
+export declare function resolvePurchaseRestoreSharingPolicy(input: PurchaseRestoreSharingPolicy | undefined): ResolvedPurchaseRestoreSharingPolicy;

package/dist/purchase-sharing.js

@@ -0,0 +1,37 @@
+/**
+ * Restore sharing (RFC "Restore sharing"): a guest lives in the device's
+ * secure store, so a reinstall, a new device, or a second device on the same
+ * store account is a new guest while the store keeps returning the
+ * purchase's non-consumable with the buyer's account binding (Google Play
+ * `obfuscatedAccountId`, StoreKit `appAccountToken`). Under the `share`
+ * policy the backend accepts the store's own verification of a restored
+ * non-consumable as the proof of ownership and grants the restoring player
+ * its own entitlement, linked to the purchase. Earlier holders keep theirs,
+ * up to `maxHolders` players per purchase; a refund or revocation of the
+ * purchase revokes every holder. Consumables and subscriptions are never
+ * shared.
+ */
+export const defaultPurchaseRestoreMaxHolders = 5;
+/** The policy `createGameServicesBackend` uses when none is passed: restores across players are refused. */
+export const refusePurchaseRestoreSharing = Object.freeze({
+    mode: 'refuse',
+});
+/** The reference stack's policy: share, up to the default number of holders. */
+export const sharePurchaseRestores = Object.freeze({
+    mode: 'share',
+});
+/** The largest `maxHolders` a policy accepts; a purchase's holders are read one by one. */
+export const maxPurchaseRestoreHolders = 100;
+export function resolvePurchaseRestoreSharingPolicy(input) {
+    const policy = input ?? refusePurchaseRestoreSharing;
+    if (policy.mode !== 'share' && policy.mode !== 'refuse') {
+        throw new Error('restoreSharing.mode must be share or refuse.');
+    }
+    const maxHolders = policy.maxHolders ?? defaultPurchaseRestoreMaxHolders;
+    if (!Number.isSafeInteger(maxHolders)
+        || maxHolders < 1
+        || maxHolders > maxPurchaseRestoreHolders) {
+        throw new Error(`restoreSharing.maxHolders must be an integer from 1 to ${String(maxPurchaseRestoreHolders)}.`);
+    }
+    return { mode: policy.mode, maxHolders };
+}

package/dist/runtime.d.ts

@@ -1,3 +1,4 @@
+import { type AccountDeletionClient } from './account-deletion.js';
 import type { AnalyticsSink } from '@mpgd/analytics';
 import type { PlatformGateway, PlatformTarget } from '@mpgd/platform';
 import { type GameServicesBackendApi, type GameServicesBackendTransport, type GameServicesClient, type GameServicesHeaderResolver } from './client.js';
@@ -15,6 +16,11 @@ export interface GameServicesRuntime {
   readonly target?: GameServicesLedgerTarget;
   readonly client?: GameServicesClient;
   readonly monetizationRecovery?: RecoverableMonetizationClient;
+  /**
+  * The signed-in player's account deletion (`POST /game-services/account/delete`)
+  * with the runtime's headers; present with an authoritative `baseUrl`.
+  */
+  readonly accountDeletion?: AccountDeletionClient;
 }
 interface CreateGameServicesRuntimeCommonInput {
   readonly gateway: PlatformGateway;

package/dist/runtime.js

@@ -1,3 +1,4 @@
+import { createAccountDeletionClient } from './account-deletion.js';
 import { createGameServicesClient, createGameServicesFetchBackendTransport, createGameServicesHttpBackendApi, createGameServicesOrpcBackendApi, createGameServicesOrpcClient, resolveGameServicesRequestHeaders, } from './client.js';
 import { createRecoverableMonetizationClient, } from './monetization-recovery.js';
 export function createGameServicesRuntime(input) {
@@ -93,6 +94,18 @@ export function createGameServicesRuntime(input) {
         target,
         client: routedClient,
         ...(monetizationRecovery === undefined ? {} : { monetizationRecovery }),
+        ...(baseUrl === undefined
+            ? {}
+            : {
+                accountDeletion: createAccountDeletionClient({
+                    // The deletion route is plain HTTP next to the oRPC handler: an
+                    // oRPC URL names the handler's `/rpc` prefix, which the route
+                    // does not sit under.
+                    baseUrl: input.transport === 'orpc' ? baseUrl.replace(/\/rpc\/?$/u, '') : baseUrl,
+                    ...(input.headers === undefined ? {} : { headers: input.headers }),
+                    ...(input.getHeaders === undefined ? {} : { getHeaders: input.getHeaders }),
+                }),
+            }),
     };
 }
 function withRuntimeHeaders(transport, input) {

package/dist/server.d.ts

@@ -2,9 +2,11 @@ import { type AnalyticsSink } from '@mpgd/analytics';
 import { type AdPlacements, type ProductCatalog } from '@mpgd/catalog';
 import { type GameServicesBackendApi, type GameServicesBackendTransport, type GameServicesBackendTransportRequest, type GameServicesBackendTransportResponse } from './client.js';
 import { type CommerceEvidenceRegistry } from './commerce-evidence-registry.js';
+import { type PlayerDataErasureInput, type PlayerDataErasureResult } from './account-deletion.js';
 import { type GameServicesHealthResponse } from './contract.js';
 import { type GameServicesEvidenceVerifier, type GameServicesPurchaseGrantFinalizer } from './evidence-verification.js';
-import { type ClaimAdRewardRequest, type ClaimAdRewardResponse, type EntitlementLedgerGrant, type EntitlementLedgerResult, type EntitlementLedgerRevocation, type EntitlementRevocationTransaction, type GameServicesAdRewardTarget, type GameServicesStoreTarget, type LeaderboardScoreTransaction, type ProductGrantTransaction, type PurchaseLedgerStatusRequest, type RecordLeaderboardScoreRequest, type RecordLeaderboardScoreResponse, type VerifyPurchaseRequest, type VerifyPurchaseResponse } from './types.js';
+import { type ClaimAdRewardRequest, type ClaimAdRewardResponse, type EntitlementLedgerGrant, type EntitlementLedgerNote, type EntitlementLedgerResult, type EntitlementLedgerRevocation, type EntitlementRevocationTransaction, type GameServicesAdRewardTarget, type GameServicesStoreTarget, type LeaderboardScoreTransaction, type ProductGrantTransaction, type PurchaseLedgerStatusRequest, type RecordLeaderboardScoreRequest, type RecordLeaderboardScoreResponse, type VerifyPurchaseRequest, type VerifyPurchaseResponse } from './types.js';
+import { type PurchaseRestoreSharingPolicy } from './purchase-sharing.js';
 export { gameServicesRequestLimits, GameServicesRequestValidationError } from './validation.js';
 export { listActiveEntitlementTransactions, readPurchaseLedgerStatuses, revokeEntitlementGrant, RevocationKeyConflictError, type RevokeEntitlementGrantResult, } from './commerce-ledger.js';
 type CorsHeaders = Record<string, string>;
@@ -33,6 +35,15 @@ export interface CreateGameServicesBackendInput {
   */
   readonly commerceEvidenceRegistry?: CommerceEvidenceRegistry;
   /**
+  * How a restored non-consumable that the store binds to another player is
+  * answered (RFC "Restore sharing"). `{ mode: 'share' }` grants the
+  * restoring player its own entitlement while earlier holders keep theirs,
+  * up to `maxHolders` (5) players per purchase. Defaults to
+  * `{ mode: 'refuse' }`, which keeps answering the binding mismatch; the
+  * reference Worker shares by default (`GAME_SERVICES_RESTORE_SHARING`).
+  */
+  readonly restoreSharing?: PurchaseRestoreSharingPolicy;
+  /**
   * Receives unexpected (non-validation) failures such as store errors before the
   * transport answers with the generic `INTERNAL_ERROR` code. Defaults to `console.error`.
   * The hook is diagnostics only: if it throws or returns a rejecting promise, the failure
@@ -87,11 +98,42 @@ export interface GameServicesStore {
   findEntitlementRevocations?(input: {
     readonly ledgerEntryIds: readonly string[];
   }): Promise<readonly EntitlementRevocationTransaction[]>;
+  /**
+  * The grants of `source` whose `evidenceVerificationId` starts with
+  * `prefix` (at most `limit`), any order: restore sharing lists a purchase's
+  * shared grants with it in one indexed read (RFC "Restore sharing").
+  * Optional: without it the shares are read slot by slot.
+  */
+  findEntitlementTransactionsByEvidencePrefix?(input: {
+    readonly source: EntitlementLedgerGrant['source'];
+    readonly prefix: string;
+    readonly limit: number;
+  }): Promise<readonly ProductGrantTransaction[]>;
+  /**
+  * Keeps a ledger note (a store event that grants nothing), once per
+  * `noteId`: a replay answers `alreadyRecorded: true` and keeps the first.
+  * Optional: a store without it still answers the event, with a log only.
+  */
+  recordEntitlementNote?(input: EntitlementLedgerNote): Promise<{
+    readonly alreadyRecorded: boolean;
+  }>;
+  /** The notes about the given grants, oldest first. */
+  findEntitlementNotes?(input: {
+    readonly ledgerEntryIds: readonly string[];
+  }): Promise<readonly EntitlementLedgerNote[]>;
   recordLeaderboardScore(input: RecordLeaderboardScoreRequest, options?: {
     readonly recordedAt?: string;
   }): Promise<RecordLeaderboardScoreResponse>;
   getLeaderboardTransaction(ledgerEntryId: string): Promise<LeaderboardScoreTransaction | undefined>;
   listLeaderboardTransactions(): Promise<readonly LeaderboardScoreTransaction[]>;
+  /**
+  * Account deletion (`./account-deletion`): deletes the player's grants,
+  * revocations, notes, and scores, except purchase grants and what reverses
+  * or annotates them, which are kept detached from the player (new ids,
+  * `retainedPlayerId`, no `playerId` payload key). Idempotent. Optional: the
+  * Worker's D1 deployment erases its tables in one batch instead.
+  */
+  erasePlayerData?(input: PlayerDataErasureInput): Promise<PlayerDataErasureResult>;
 }
 export interface EntitlementPlatformEvidenceIdentity {
   readonly source: Extract<EntitlementLedgerGrant['source'], 'purchase' | 'ad_reward'>;
@@ -122,6 +164,7 @@ export declare class InMemoryGameServicesStore implements GameServicesStore {
   private readonly revocationsByKey;
   private readonly revocationsByGrant;
   private readonly revocationsByEvidence;
+  private readonly notesById;
   private readonly leaderboardTransactionsByRun;
   private readonly leaderboardTransactionsById;
   recordEntitlementGrant(input: EntitlementLedgerGrant): Promise<EntitlementLedgerResult>;
@@ -134,6 +177,11 @@ export declare class InMemoryGameServicesStore implements GameServicesStore {
     readonly source: EntitlementLedgerGrant['source'];
     readonly evidenceVerificationId: string;
   }): Promise<ProductGrantTransaction | undefined>;
+  findEntitlementTransactionsByEvidencePrefix(input: {
+    readonly source: EntitlementLedgerGrant['source'];
+    readonly prefix: string;
+    readonly limit: number;
+  }): Promise<readonly ProductGrantTransaction[]>;
   findEntitlementTransactionByPlatformEvidence(input: EntitlementPlatformEvidenceIdentity): Promise<ProductGrantTransaction | undefined>;
   getEntitlementTransaction(ledgerEntryId: string): Promise<ProductGrantTransaction | undefined>;
   listEntitlementTransactions(): Promise<readonly ProductGrantTransaction[]>;
@@ -142,11 +190,22 @@ export declare class InMemoryGameServicesStore implements GameServicesStore {
   findEntitlementRevocations(input: {
     readonly ledgerEntryIds: readonly string[];
   }): Promise<readonly EntitlementRevocationTransaction[]>;
+  recordEntitlementNote(input: EntitlementLedgerNote): Promise<{
+    readonly alreadyRecorded: boolean;
+  }>;
+  findEntitlementNotes(input: {
+    readonly ledgerEntryIds: readonly string[];
+  }): Promise<readonly EntitlementLedgerNote[]>;
   recordLeaderboardScore(input: RecordLeaderboardScoreRequest, options?: {
     readonly recordedAt?: string;
   }): Promise<RecordLeaderboardScoreResponse>;
   getLeaderboardTransaction(ledgerEntryId: string): Promise<LeaderboardScoreTransaction | undefined>;
   listLeaderboardTransactions(): Promise<readonly LeaderboardScoreTransaction[]>;
+  erasePlayerData(input: PlayerDataErasureInput): Promise<PlayerDataErasureResult>;
+  private rememberEntitlementRevocation;
+  private forgetEntitlementRevocation;
+  private forgetEntitlementTransaction;
+  private rememberEntitlementTransaction;
   private rankFor;
   private sortedLeaderboardTransactions;
 }