@learncard/partner-connect 0.2.14 → 0.3.0

package/README.md

@@ -305,6 +305,102 @@ if (recipients.hasMore) {
 
 **Returns:** `{ records: TemplateRecipientRecord[], hasMore: boolean, cursor?: string, total?: number }`
 
+### `sendNotification(input)`
+
+Send a notification to the current user from this app. The notification appears in the user's LearnCard notification inbox, even after they leave the app.
+
+```typescript
+await learnCard.sendNotification({
+    title: 'Sprint Bonus!',
+    body: '+10 coins from Sprint 42',
+    actionPath: '/',
+    category: 'reward',
+});
+```
+
+**Parameters:**
+
+-   `title` _(optional)_: Notification title
+-   `body` _(optional)_: Notification body text
+-   `actionPath` _(optional)_: Deep link path within the app (e.g. `'/prizes'`). Must be an absolute pathname starting with `/`. This path is appended to the app's configured embed URL when the user taps the notification. For example, if your embed URL is `https://myapp.com` and `actionPath` is `'/challenges/42'`, the app will open at `https://myapp.com/challenges/42`. Hash routes (e.g. `'/#/page'`) are **not** supported — use pathname-based routing.
+-   `category` _(optional)_: Grouping category (e.g. `'reward'`, `'announcement'`, `'status'`)
+-   `priority` _(optional)_: `'normal'` (default) or `'high'`. Affects visual styling of the notification card and toast. Does not change delivery priority or ordering.
+
+At least one of `title` or `body` is required.
+
+**Returns:** `{ sent: boolean }`
+
+> **Note:** This method sends a notification to the _current_ user (self-notification) via the `send-notification` app event. For server-to-server notifications to arbitrary users, use the `POST /app-store/listing/{listingId}/notify` brain-service route directly from your app backend.
+
+---
+
+### `incrementCounter(key, amount)`
+
+Increment or decrement an app-scoped counter for the current user. Counters are scoped to (user, app, key). If the counter does not exist, it is created with the given amount as its initial value.
+
+```typescript
+// Add 10 coins
+const result = await learnCard.incrementCounter('coins', 10);
+console.log(result.newValue); // 10
+
+// Spend 5 coins
+const spent = await learnCard.incrementCounter('coins', -5);
+console.log(spent.newValue); // 5
+```
+
+**Parameters:**
+
+-   `key` _(required)_: Counter name. Must match `[a-zA-Z0-9_-]+`, max 64 characters.
+-   `amount` _(required)_: Integer value to add. Use a negative integer to decrement.
+
+**Returns:** `{ key: string, previousValue: number, newValue: number }`
+
+**Limits:**
+
+-   Max 50 distinct counter keys per user per app
+-   Max 100 writes per user per app per minute
+-   Amount must be a finite integer
+
+---
+
+### `getCounter(key)`
+
+Read the current value of an app-scoped counter. Returns `{ value: 0 }` if the counter does not exist.
+
+```typescript
+const { value } = await learnCard.getCounter('coins');
+console.log('Balance:', value);
+```
+
+**Parameters:**
+
+-   `key` _(required)_: Counter name (same format as `incrementCounter`)
+
+**Returns:** `{ key: string, value: number, updatedAt: string | null }`
+
+---
+
+### `getCounters(keys?)`
+
+Read multiple app-scoped counters at once. If `keys` is omitted, returns all counters for this app.
+
+```typescript
+// Specific keys
+const { counters } = await learnCard.getCounters(['coins', 'spins', 'streak']);
+counters.forEach(c => console.log(c.key, c.value));
+
+// All counters
+const all = await learnCard.getCounters();
+```
+
+**Parameters:**
+
+-   `keys` _(optional)_: Array of counter names to fetch (max 50). Omit to return all.
+
+**Returns:** `{ counters: Array<{ key: string, value: number, updatedAt: string | null }> }`
+
+---
+
 ### `launchFeature(featurePath, initialPrompt?)`
 
 Launch a feature in the LearnCard host application.

package/dist/index.d.ts

@@ -10,44 +10,73 @@ export { AppEvent, AppEventResponse, CheckCredentialEvent, SendCredentialEvent }
  */
 interface PartnerConnectOptions {
     /**
-     * The origin(s) of the LearnCard host
-     *
-     * This can be a single string or an array of strings to serve as a whitelist for
-     * the `lc_host_override` query parameter.
-     *
-     * **Origin Configuration Hierarchy:**
-     * 1. **Hardcoded Default**: `https://learncard.app` (security anchor)
-     * 2. **Query Parameter Override**: `?lc_host_override=https://staging.learncard.app`
-     *    - Checked against whitelist if `hostOrigin` is provided
-     *    - Used for staging/testing environments
-     * 3. **Configured Origin**: First value in array or single string value
-     *
-     * **Security Model:**
-     * - The SDK enforces STRICT origin validation
-     * - Incoming messages must EXACTLY match the active host origin
-     * - Prevents origin spoofing: even if malicious query param is added,
-     *   messages from unauthorized origins are rejected
+     * The origin(s) of the LearnCard host.
+     *
+     * Each entry may be either an **exact origin** (`https://learncard.app`) or a
+     * **wildcard pattern** where `*` stands in for a single DNS label portion in
+     * the host portion of the origin (e.g. `https://*.learncard.app`,
+     * `https://*.vetpass.app`). Wildcards are **only** allowed in the host and
+     * only as label(s); the protocol and port must always match exactly.
+     *
+     * Wildcard patterns match any non-empty chain of labels. So
+     * `https://*.learncard.app` matches both `https://staging.learncard.app` and
+     * `https://pr-123.preview.learncard.app`, but **not** `https://learncard.app`
+     * itself (include the bare origin explicitly if you need it) and **not**
+     * `https://evil.learncard.app.attacker.com` (the suffix must match).
+     *
+     * **Origin Configuration Hierarchy at runtime:**
+     * 1. `window.location.ancestorOrigins[0]` (when available) — the real parent
+     *    origin as reported by the browser, validated against the effective
+     *    whitelist. This source cannot be spoofed by a malicious query param.
+     * 2. `?lc_host_override=<origin>` query parameter — validated against the
+     *    whitelist. Used by the LearnCard host to tell the SDK which origin it
+     *    is loading from.
+     * 3. `sessionStorage['lc_host_override']` — a previously-validated override
+     *    persisted across in-iframe navigation.
+     * 4. First value in the configured `hostOrigin` array / single string.
+     * 5. `PartnerConnect.DEFAULT_HOST_ORIGIN` (`https://learncard.app`).
+     *
+     * The partner app's configured whitelist is combined with a small built-in
+     * list of LearnCard tenant domains (see `disableDefaultTenants` to opt out).
+     * This lets a partner app work out-of-the-box inside any current or future
+     * `*.learncard.app`, `*.learncard.ai`, or `*.vetpass.app` tenant without a
+     * re-deploy.
      *
      * **Examples:**
      *
-     * Single origin (production):
+     * Single origin (production only):
      * ```typescript
      * hostOrigin: 'https://learncard.app'
-     * // Uses: https://learncard.app
-     * // Override: ?lc_host_override=https://staging.learncard.app (not validated)
      * ```
      *
-     * Multiple origins (whitelist for staging):
+     * Wildcard whitelist (covers staging + preview):
+     * ```typescript
+     * hostOrigin: ['https://learncard.app', 'https://*.learncard.app']
+     * ```
+     *
+     * Custom tenant alongside the built-in LearnCard defaults:
      * ```typescript
-     * hostOrigin: ['https://learncard.app', 'https://staging.learncard.app']
-     * // Default: https://learncard.app
-     * // Override: ?lc_host_override=https://staging.learncard.app (validated)
-     * // Invalid: ?lc_host_override=https://evil.com (rejected)
+     * hostOrigin: ['https://partner.example.com']
+     * // learncard.app / *.learncard.app / *.learncard.ai / vetpass.app / *.vetpass.app
+     * // are ALSO trusted because disableDefaultTenants is false.
      * ```
      *
      * @default 'https://learncard.app'
      */
     hostOrigin?: string | string[];
+    /**
+     * Opt out of the built-in LearnCard tenant whitelist.
+     *
+     * By default, the SDK merges `hostOrigin` with a curated list of LearnCard
+     * and tenant domains (see `PartnerConnect.DEFAULT_TRUSTED_TENANTS`) so that
+     * partner apps work on any LearnCard-managed tenant without reconfiguration.
+     *
+     * Set to `true` if you want the partner app to **only** trust the origins
+     * you pass in `hostOrigin`.
+     *
+     * @default false
+     */
+    disableDefaultTenants?: boolean;
     /**
      * Whether to allow native app origins (default: true)
      *
@@ -158,6 +187,17 @@ interface RequestConsentOptions {
      */
     redirect?: boolean;
 }
+/**
+ * Payload for REQUEST_CONSENT action
+ */
+interface RequestConsentPayload {
+    /**
+     * URI of the consent contract. If not provided, the system will attempt
+     * to use the contract configured for the current app listing.
+     */
+    contractUri?: string;
+    redirect?: boolean;
+}
 /**
  * Response from REQUEST_CONSENT action
  */
@@ -242,17 +282,236 @@ interface TemplateRecipientsResponse {
     cursor?: string;
     total?: number;
 }
+/**
+ * Options for REQUEST_LEARNER_CONTEXT action
+ */
+interface RequestLearnerContextOptions {
+    /**
+     * Whether to include credentials in the context
+     * @default true
+     */
+    includeCredentials?: boolean;
+    /**
+     * Whether to include personal data (name, bio, etc.) in the context
+     * @default false
+     */
+    includePersonalData?: boolean;
+    /**
+     * Format of the response
+     * - 'prompt': Returns LLM-ready formatted text
+     * - 'structured': Returns structured data object
+     * @default 'prompt'
+     */
+    format?: 'prompt' | 'structured';
+    /**
+     * Optional instructions to guide the LLM prompt generation
+     */
+    instructions?: string;
+    /**
+     * Level of detail in the generated prompt
+     * @default 'compact'
+     */
+    detailLevel?: 'compact' | 'expanded';
+}
+/**
+ * Raw data included in learner context response (when format is 'structured')
+ */
+interface LearnerContextRawData {
+    /** Array of Verifiable Credentials */
+    credentials: unknown[];
+    /** Personal data if requested and available (name, bio, etc.) */
+    personalData?: Record<string, unknown>;
+}
+/**
+ * Response from REQUEST_LEARNER_CONTEXT action
+ */
+interface LearnerContextResponse {
+    /** LLM-ready formatted prompt text */
+    prompt: string;
+    /** Raw structured data (only included when format is 'structured') */
+    raw?: LearnerContextRawData;
+    /** User's DID */
+    did: string;
+    /** User's display name if available */
+    displayName?: string;
+}
+/**
+ * Keywords for next steps in summary credential data
+ */
+interface SummaryCredentialKeyword {
+    occupations: string[] | null;
+    careers: string[] | null;
+    jobs: string[] | null;
+    skills: string[] | null;
+    fieldOfStudy: string | null;
+}
+/**
+ * Skill item in summary credential data
+ */
+interface SummaryCredentialSkill {
+    title: string;
+    description: string;
+}
+/**
+ * Next step item in summary credential data
+ *
+ * `keywords` is optional. Omit it entirely (or pass `undefined`) when you do not
+ * have taxonomy data — you no longer need to pass a struct of `null` fields.
+ */
+interface SummaryCredentialNextStep {
+    title: string;
+    description: string;
+    keywords?: SummaryCredentialKeyword;
+}
+/**
+ * Reflection item in summary credential data
+ */
+interface SummaryCredentialReflection {
+    title: string;
+    description: string;
+}
+/**
+ * Summary data for an AI Session credential
+ * Contains structured information about what was learned
+ */
+interface SummaryCredentialData {
+    /** Short, concise title for the learning session or credential */
+    title: string;
+    /** Comprehensive summary of what happened during the session */
+    summary: string;
+    /** Bullet points of key knowledge gained */
+    learned: string[];
+    /** Categorized skills learned during the session */
+    skills: SummaryCredentialSkill[];
+    /** Recommended follow-up activities or learning modules */
+    nextSteps: SummaryCredentialNextStep[];
+    /** Reflections on the learning experience */
+    reflections: SummaryCredentialReflection[];
+}
+/**
+ * Input for creating and sending an AI Session credential
+ */
+interface SendAiSessionCredentialInput {
+    /** Title of this specific AI session */
+    sessionTitle: string;
+    /** Structured summary data about what was learned */
+    summaryData: SummaryCredentialData;
+    /** Optional metadata for the session */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Response from sending an AI Session credential
+ */
+interface SendAiSessionCredentialResponse {
+    /** URI of the AI Topic (parent) boost */
+    topicUri: string;
+    /** URI of the topic credential, if a new topic was created */
+    topicCredentialUri?: string;
+    /** URI of the created AI Session credential */
+    sessionCredentialUri: string;
+    /** URI of the session boost (child of topic) */
+    sessionBoostUri: string;
+    /** Whether a new topic was created (true) or existing was used (false) */
+    isNewTopic: boolean;
+}
+/**
+ * Input for sending a notification to the current user from this app.
+ * The notification appears in the user's LearnCard notification inbox.
+ */
+interface AppNotificationInput {
+    /** Notification title */
+    title?: string;
+    /** Notification body text */
+    body?: string;
+    /** Deep link path within the app (e.g. '/prizes') */
+    actionPath?: string;
+    /** Grouping category (e.g. 'reward', 'announcement', 'status') */
+    category?: string;
+    /** Notification priority */
+    priority?: 'normal' | 'high';
+}
+/**
+ * Response from sendNotification
+ */
+interface AppNotificationResponse {
+    sent: boolean;
+}
+/**
+ * Response from incrementCounter
+ */
+interface IncrementCounterResponse {
+    key: string;
+    previousValue: number;
+    newValue: number;
+}
+/**
+ * Response from getCounter
+ */
+interface GetCounterResponse {
+    key: string;
+    value: number;
+    updatedAt: string | null;
+}
+/**
+ * Response from getCounters
+ */
+interface GetCountersResponse {
+    counters: GetCounterResponse[];
+}
 /**
  * Error codes that can be returned by the LearnCard host
  */
 type ErrorCode = 'LC_TIMEOUT' | 'LC_UNAUTHENTICATED' | 'CREDENTIAL_NOT_FOUND' | 'USER_REJECTED' | 'UNAUTHORIZED' | 'TEMPLATE_NOT_FOUND' | 'BOOST_NOT_FOUND' | 'INSUFFICIENT_PERMISSIONS' | string;
 /**
- * Error object returned when a request fails
+ * Error object returned when a request fails.
+ *
+ * Historically the SDK rejected with a plain `{ code, message }` object. As of
+ * v0.3.0 we reject with a {@link PartnerConnectError} instance instead, which
+ * still satisfies this interface (it has both `code` and `message` fields), so
+ * existing consumers that do `if (err.code === '...')` continue to work
+ * unchanged.
  */
 interface LearnCardError {
     code: ErrorCode;
     message: string;
 }
+/**
+ * Typed error class for all Partner Connect SDK rejections.
+ *
+ * Use `instanceof PartnerConnectError` to narrow caught errors and unlock
+ * exhaustive `switch` checks on `code`. Both `code` and `message` are present
+ * (so the legacy `LearnCardError` object shape is preserved), and `name` is
+ * always `'PartnerConnectError'`.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await learnCard.requestLearnerContext();
+ * } catch (err) {
+ *   if (err instanceof PartnerConnectError) {
+ *     switch (err.code) {
+ *       case 'LC_UNAUTHENTICATED': showLogin(); break;
+ *       case 'USER_REJECTED':      showPrivacyNotice(); break;
+ *       case 'UNAUTHORIZED':       showPermissionsError(); break;
+ *       default:                   console.error(err);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+declare class PartnerConnectError extends Error implements LearnCardError {
+    readonly code: ErrorCode;
+    constructor(code: ErrorCode, message: string);
+    /**
+     * Wrap any incoming `LearnCardError`-shaped value into a `PartnerConnectError`.
+     * Returns the value unchanged if it is already an instance.
+     *
+     * Used internally at every reject site so callers always receive a typed
+     * `PartnerConnectError`, regardless of whether the failure originated from
+     * the host (over postMessage), an SDK timeout, or `destroy()`.
+     */
+    static from(input: LearnCardError | unknown): PartnerConnectError;
+}
 /**
  * Internal message structure sent via postMessage
  */
@@ -307,6 +566,19 @@ interface PendingRequest {
 declare class PartnerConnect {
     /** Default host origin (security anchor) */
     static readonly DEFAULT_HOST_ORIGIN = "https://learncard.app";
+    /**
+     * Built-in list of LearnCard-managed tenant origins.
+     *
+     * These are merged with the partner app's configured `hostOrigin` whitelist
+     * unless `disableDefaultTenants: true` is passed. This lets a partner app
+     * run inside any current or future LearnCard tenant (staging, preview,
+     * VetPass, etc.) without needing a re-deploy each time a new tenant is
+     * onboarded.
+     *
+     * Patterns follow the same rules as user-supplied `hostOrigin` entries:
+     * `*` is a wildcard for one or more DNS labels in the host portion.
+     */
+    static readonly DEFAULT_TRUSTED_TENANTS: readonly string[];
     private hostOrigins;
     private activeHostOrigin;
     private allowNativeAppOrigins;
@@ -318,16 +590,60 @@ declare class PartnerConnect {
     constructor(options?: PartnerConnectOptions);
     /**
      * Configure the active host origin using the following hierarchy:
-     * 1. Check for `lc_host_override` query parameter (for staging/testing)
-     * 2. Fall back to first configured origin
-     * 3. Fall back to DEFAULT_HOST_ORIGIN
-     *
-     * This origin will be used for all outgoing messages and incoming message validation.
+     * 1. `window.location.ancestorOrigins[0]` (when supported) — the browser's
+     *    view of who our parent frame is. Cannot be forged by a malicious
+     *    `lc_host_override` query param and therefore takes precedence.
+     * 2. `?lc_host_override=<origin>` query param (for staging / cross-tenant).
+     * 3. `sessionStorage` value saved from a previously-validated override.
+     * 4. First configured origin.
+     * 5. `DEFAULT_HOST_ORIGIN`.
+     *
+     * When a valid override is found in the query parameter, it is persisted
+     * to sessionStorage so subsequent in-iframe navigations in the same tab
+     * continue to use the same active origin.
+     */
+    private static readonly SESSION_STORAGE_KEY;
+    /**
+     * Read `window.location.ancestorOrigins[0]` without throwing if the
+     * property is unavailable (Firefox) or the list is empty (top-level
+     * context, e.g. running outside of an iframe).
      */
+    private readAncestorOrigin;
     private configureActiveOrigin;
+    private persistOverride;
     private isOriginNativeApp;
     /**
-     * Check if an origin is in the configured whitelist
+     * Internal placeholder substituted in for `*` so that `new URL(...)` can
+     * parse a wildcard pattern. Chosen to be a syntactically-valid DNS label
+     * that cannot collide with a real hostname.
+     */
+    private static readonly WILDCARD_PLACEHOLDER;
+    /** `*` (any number of occurrences) for replacement in the pattern. */
+    private static readonly WILDCARD_REGEX;
+    /** The required leading-label form a wildcard pattern must take. */
+    private static readonly WILDCARD_LEADING_PREFIX;
+    /**
+     * Check whether a candidate origin matches a configured whitelist entry.
+     *
+     * Supports exact matches and wildcard patterns. A wildcard entry has the
+     * form `<protocol>://*.<domain>` and matches any origin with the same
+     * protocol, same port, and a host ending in `.<domain>` with at least
+     * one non-empty DNS label in place of the `*`.
+     *
+     * Examples with pattern `https://*.learncard.app`:
+     * - `https://staging.learncard.app`      → match
+     * - `https://pr-1.preview.learncard.app` → match
+     * - `https://learncard.app`              → no match (no subdomain)
+     * - `http://staging.learncard.app`       → no match (protocol mismatch)
+     * - `https://learncard.app.attacker.com` → no match (suffix mismatch)
+     *
+     * Exposed as a public static so it can be unit-tested directly without
+     * standing up a full SDK instance.
+     */
+    static matchesOriginPattern(candidate: string, pattern: string): boolean;
+    /**
+     * Check if an origin is in the effective whitelist (exact origins +
+     * wildcard patterns + optional native-app origins).
      */
     private isOriginInWhitelist;
     /**
@@ -513,25 +829,30 @@ declare class PartnerConnect {
     /**
      * Request user consent for permissions
      *
-     * @param contractUri - URI of the consent contract
+     * @param contractUri - URI of the consent contract (optional for App Store apps with configured contracts)
+     * @param options - Additional options including redirect behavior
      * @returns Promise resolving to consent response
      *
      * @example
      * ```typescript
-     * // Without redirect (default) - returns VP in response if app owns the contract
+     * // With explicit contract URI (for external/non-app store integrations)
      * const response = await learnCard.requestConsent('lc:network:network.learncard.com/trpc:contract:abc123');
      * if (response.granted) {
      *   console.log('User granted consent');
-     *   if (response.vp) {
-     *     console.log('VP:', response.vp);
-     *   }
+     * }
+     *
+     * // Without contract URI (uses app's configured contract from integration)
+     * // This works for App Store apps that have configured a contract in their integration
+     * const response = await learnCard.requestConsent();
+     * if (response.granted) {
+     *   console.log('User granted consent using listing contract');
      * }
      *
      * // With redirect - redirects to contract's redirectUrl with VP in URL params
-     * const response = await learnCard.requestConsent('lc:network:network.learncard.com/trpc:contract:abc123', { redirect: true });
+     * const response = await learnCard.requestConsent(undefined, { redirect: true });
      * ```
      */
-    requestConsent(contractUri: string, options?: RequestConsentOptions): Promise<ConsentResponse>;
+    requestConsent(contractUri?: string, options?: RequestConsentOptions): Promise<ConsentResponse>;
     /**
      * Initiate a template-based credential issuance flow
      *
@@ -552,6 +873,36 @@ declare class PartnerConnect {
      * ```
      */
     initiateTemplateIssue(templateId: string, draftRecipients?: string[]): Promise<TemplateIssueResponse>;
+    /**
+     * Request comprehensive learner context for AI tutoring systems.
+     *
+     * This method retrieves the user's credentials and personal data,
+     * then formats them into an LLM-ready prompt that can be injected directly into
+     * an AI system prompt.
+     *
+     * @param options - Configuration options for what data to include and how to format it
+     * @returns Promise resolving to learner context with prompt and optional raw data
+     *
+     * @example
+     * ```typescript
+     * // Get LLM-ready prompt with credentials and personal data
+     * const context = await learnCard.requestLearnerContext({
+     *   includeCredentials: true,
+     *   includePersonalData: true,
+     *   format: 'prompt',
+     *   instructions: 'Focus on technical skills and certifications',
+     *   detailLevel: 'expanded'
+     * });
+     *
+     * // Use in AI system prompt
+     * const systemPrompt = `You are a helpful tutor. ${context.prompt}`;
+     *
+     * // Access structured data if needed
+     * console.log('User DID:', context.did);
+     * console.log('Credentials count:', context.raw?.credentials.length);
+     * ```
+     */
+    requestLearnerContext(options?: RequestLearnerContextOptions): Promise<LearnerContextResponse>;
     /**
      * Send a generic event to be processed by the brain service on behalf of this app.
      * This is used for backend-like operations such as issuing credentials.
@@ -574,6 +925,36 @@ declare class PartnerConnect {
      * ```
      */
     sendAppEvent<T = AppEventResponse>(event: AppEvent): Promise<T>;
+    /**
+     * Create and send an AI Session credential to the user.
+     *
+     * This method manages the AI Topic → AI Session hierarchy:
+     * - Ensures an AI Topic exists for this app (creates one if needed)
+     * - Creates a new AI Session as a child of the topic
+     * - The topic appears in the user's AI Sessions page with the app's name
+     * - All sessions from this app are organized under that topic
+     *
+     * @param input - Session details including title and optional metadata
+     * @returns Promise resolving to topic and session URIs
+     */
+    sendAiSessionCredential(input: SendAiSessionCredentialInput): Promise<SendAiSessionCredentialResponse>;
+    /**
+     * Send a notification to the current user from this app.
+     * The notification appears in the user's LearnCard notification inbox.
+     */
+    sendNotification(input: AppNotificationInput): Promise<AppNotificationResponse>;
+    /**
+     * Increment or decrement an app-scoped counter for the current user.
+     */
+    incrementCounter(key: string, amount: number): Promise<IncrementCounterResponse>;
+    /**
+     * Read the current value of an app-scoped counter for the current user.
+     */
+    getCounter(key: string): Promise<GetCounterResponse>;
+    /**
+     * Read multiple app-scoped counters at once for the current user.
+     */
+    getCounters(keys?: string[]): Promise<GetCountersResponse>;
     /**
      * Clean up the SDK and remove event listeners
      */
@@ -596,4 +977,4 @@ declare class PartnerConnect {
  */
 declare function createPartnerConnect(options?: PartnerConnectOptions): PartnerConnect;
 
-export { CheckCredentialInput, CheckCredentialResponse, CheckIssuanceStatusInput, ConsentResponse, CredentialSearchResponse, CredentialSpecificResponse, ErrorCode, GetTemplateRecipientsInput, IdentityResponse, LearnCardError, PartnerConnect, PartnerConnectOptions, PendingRequest, PostMessageRequest, PostMessageResponse, RequestConsentOptions, SendCredentialResponse, TemplateCredentialInput, TemplateCredentialResponse, TemplateIssuanceStatusResponse, TemplateIssueResponse, TemplateRecipientRecord, TemplateRecipientsResponse, VPRQuery, VerifiablePresentationRequest, createPartnerConnect, createPartnerConnect as default };
+export { AppNotificationInput, AppNotificationResponse, CheckCredentialInput, CheckCredentialResponse, CheckIssuanceStatusInput, ConsentResponse, CredentialSearchResponse, CredentialSpecificResponse, ErrorCode, GetCounterResponse, GetCountersResponse, GetTemplateRecipientsInput, IdentityResponse, IncrementCounterResponse, LearnCardError, LearnerContextRawData, LearnerContextResponse, PartnerConnect, PartnerConnectError, PartnerConnectOptions, PendingRequest, PostMessageRequest, PostMessageResponse, RequestConsentOptions, RequestConsentPayload, RequestLearnerContextOptions, SendAiSessionCredentialInput, SendAiSessionCredentialResponse, SendCredentialResponse, SummaryCredentialData, SummaryCredentialKeyword, SummaryCredentialNextStep, SummaryCredentialReflection, SummaryCredentialSkill, TemplateCredentialInput, TemplateCredentialResponse, TemplateIssuanceStatusResponse, TemplateIssueResponse, TemplateRecipientRecord, TemplateRecipientsResponse, VPRQuery, VerifiablePresentationRequest, createPartnerConnect, createPartnerConnect as default };