@salesforce/afv-skills 1.13.0 → 1.14.0

package/skills/reviewing-lwc-mobile-offline/references/komaci-eslint.md

@@ -0,0 +1,125 @@
+# Komaci ESLint Static Analysis (`@salesforce/eslint-plugin-lwc-graph-analyzer`)
+
+## Framework for the analysis
+
+The Komaci offline analyzer is exposed as the ESLint plugin `@salesforce/eslint-plugin-lwc-graph-analyzer`. Its **recommended** ruleset catches LWC patterns that prevent offline data priming. This reviewer runs the plugin against the component's JS file and translates each lint message into an actionable remediation.
+
+Use the documented per-rule remediations below — do not invent new ones — and only emit findings for rules that actually fired against the file in scope.
+
+The recommended preset enables ~36 rules; only the 7 rules documented in **Per-rule remediation** below are surfaced as findings. Other recommended-preset rules (e.g. `no-eval-usage`, `no-functions-declared-within-getter-method`) may fire but are intentionally not mapped to remediations and must be dropped from the report.
+
+## How to run the analyzer
+
+Use the bundled script. It applies the plugin's recommended ruleset with the `bundleAnalyzer` processor enabled, and on first run installs the pinned versions of `@salesforce/eslint-plugin-lwc-graph-analyzer` and `eslint` into `scripts/node_modules` so the runner is isolated from whatever versions the host project happens to ship.
+
+```bash
+scripts/run-komaci.sh path/to/component/component.js
+```
+
+Prerequisites:
+
+- The component's sibling HTML templates must live in the same directory as the JS file. The plugin's `bundleAnalyzer` processor discovers them automatically (via `readdirSync` on the bundle directory) and uses them to resolve the offline data graph across the bundle.
+- A working `npm` and Node ≥ 18 on `PATH` for the first-run install.
+
+The script emits ESLint's `--format json` output on stdout. Each `messages[*]` entry has `ruleId`, `severity`, `message`, `line`, `column`, `endLine`, `endColumn`, and `fix` (optional). Group messages by `ruleId`, then apply the per-rule remediation guidance below.
+
+To run ESLint manually outside the script — using the same pinned versions, so the recommended config resolves to the flat-config-shaped form — install once and invoke the local binary:
+
+```bash
+cd scripts
+npm install   # only on first run
+node_modules/.bin/eslint \
+  --no-config-lookup \
+  --config komaci.config.mjs \
+  --format json \
+  path/to/component/component.js
+```
+
+`scripts/komaci.config.mjs` and `scripts/package.json` ship together; the package pin (`@salesforce/eslint-plugin-lwc-graph-analyzer ^1.1.0-beta.2`, `eslint ^9.35.0`) ensures the plugin's `recommended` config is flat-config-shaped (no legacy `extends:` key).
+
+## Per-rule remediation
+
+For each rule below, the `Type`, `Description`, `Intent analysis`, and `Suggested action` strings are canonical and must be emitted unchanged in the finding. Do not paraphrase or augment them.
+
+### `@salesforce/lwc-graph-analyzer/no-private-wire-config-property`
+
+- **Type:** Private Wire Configuration Property
+- **Description:** Properties used in wire configurations must be decorated with `@api` to be public and resolvable by the wire service.
+- **Intent analysis:** The developer used properties in wire configurations without making them public using the `@api` decorator.
+- **Suggested action:**
+
+  Make the properties public by using the `@api` decorator:
+
+  - Add `@api` decorator to properties used in wire configurations.
+
+### `@salesforce/lwc-graph-analyzer/no-wire-config-references-non-local-property-reactive-value`
+
+- **Type:** Wire Configuration References Non-Local Property
+- **Description:** Wire configurations with reactive values (`$prop`) must reference only component properties, not imported values or values defined outside the component class.
+- **Intent analysis:** The developer is trying to use a non-local value (imported or module-level) as a reactive parameter in a wire configuration.
+- **Suggested action:** Wrap the non-local value in a getter:
+
+  - Introduce a getter which returns the imported value or the value of a module-level constant.
+  - Update the wire configuration to use the getter name as the reactive parameter.
+
+  ```js
+  // Instead of:
+  @wire(getData, { param: '$importedValue' })
+
+  // Use:
+  get localValue() {
+      return importedValue;
+  }
+  @wire(getData, { param: '$localValue' })
+  ```
+
+### Getter-related violations
+
+The five rules below all share the **Violations in Getter** classification and emit the same `description`, `intentAnalysis`, and `suggestedAction`. When any of them fires, emit one finding per (rule, line) pair with the strings reproduced below.
+
+Rules:
+
+- `@salesforce/lwc-graph-analyzer/no-assignment-expression-assigns-value-to-member-variable`
+- `@salesforce/lwc-graph-analyzer/no-reference-to-class-functions`
+- `@salesforce/lwc-graph-analyzer/no-reference-to-module-functions`
+- `@salesforce/lwc-graph-analyzer/no-getter-contains-more-than-return-statement`
+- `@salesforce/lwc-graph-analyzer/no-unsupported-member-variable-in-member-expression`
+
+Canonical fields:
+
+- **Type:** Violations in Getter
+- **Description:** A getter method does more than just returning a value
+- **Intent analysis:** The developer attempted to modify component state, prepare data for consumption, or reference functions within a getter function.
+- **Suggested action:**
+
+  **Compliant getter implementations**
+
+  Getters that:
+  - Directly access and return property values
+  - Return a literal value
+  - Compute and return values derived from existing properties
+
+  **Non-compliant getter implementations**
+
+  - **Violation: getters that call functions.** Getters that call functions cannot be primed for offline use cases.
+    *Remediation:* Reorganize any getter implementation code that calls a function, to move such calls out of the getter. Avoid invoking any function calls within getters.
+  - **Violation: getters with side effects.** Getters that assign values to member variables or modify state create unpredictable side effects and are not suitable for offline scenarios.
+    *Remediation:* Never assign values to member variables within a getter. LWC getters should only retrieve data without modifying any state. If you need to compute and cache a value, perform the computation and assignment in a lifecycle hook or method, then have the getter simply return the cached value.
+  - **Violation: getters that do more than just return a value.** Getters that perform complex operations beyond returning a value cannot be primed for offline use cases.
+    *Remediation:* Review the getters and make sure that they're composed to only return a value. Move any complex logic, data processing, or multiple operations into separate methods or lifecycle hooks, and have the getter simply return the result.
+
+## Rules to follow
+
+- If no action is required, return an empty list. Do not return null or any other value — return an empty array.
+- Keep issues concise; avoid duplicated issues or unnecessary analysis for things that are not real violations.
+- Stick to the instructions for the specific reviewer in scope. Issues outside that scope will be analyzed by other reviewers.
+- For each violation, provide:
+  - `type` — verbatim from the rule entry above.
+  - `description` — verbatim from the rule entry above.
+  - `intentAnalysis` — verbatim from the rule entry above.
+  - `suggestedAction` — verbatim from the rule entry above.
+  - `filePath` — the path passed to ESLint.
+  - `location` — `{ startLine, startColumn, endLine, endColumn }` taken from the ESLint message's `line`, `column`, `endLine`, `endColumn`.
+  - `code` — *optional* — the source snippet from `startLine` through `endLine`, useful when the violation spans multiple lines.
+- Drop messages whose `ruleId` is not in the seven rules above.
+- Do not make assumptions about other components that may be referenced.

package/skills/reviewing-lwc-mobile-offline/references/lwc-if.md

@@ -0,0 +1,78 @@
+# Conditional Rendering Compatibility (`lwc:if` → `if:true`/`if:false`)
+
+## Framework for the analysis
+
+The Komaci offline static analysis engine used by Salesforce Mobile App Plus and Field Service Mobile App does not support modern conditional rendering directives (`lwc:if={property}`, `lwc:elseif={property}`, `lwc:else`). These directives must be replaced with `if:true={property}` and `if:false={property}` to ensure compatibility with offline data priming.
+
+Your task:
+
+1. Inspect HTML.
+2. Identify any usage of `lwc:if={property}`, `lwc:elseif={property}`, or `lwc:else`.
+3. Recommend exactly how to replace them with `if:true` / `if:false` directives, preserving the original branching logic.
+
+**FOCUS:**
+
+- Only analyze and provide feedback on occurrences of `lwc:if={property}`, `lwc:elseif={property}`, and `lwc:else`.
+- Ignore any other directives or potential issues unrelated to those three.
+
+## Conversion rules
+
+- **`lwc:if={property}`** → replace with `if:true={property}`.
+- **`lwc:elseif={property}`** → typically requires a nested `if:false={previousCondition}` that wraps an `if:true={property}`.
+- **`lwc:else`** → has no condition of its own, so it must be wrapped by `if:false={previousCondition}` (the inverse of the relevant condition chain).
+- **Standalone `lwc:if`** (not followed by `lwc:elseif`/`lwc:else`) → still must be replaced with `if:true={property}`.
+- **Multiple condition chains** → review every template; do not stop at the first occurrence.
+
+## Conversion example
+
+`before.html`:
+
+```html
+<template>
+  <template lwc:if="{conditionOne}">
+    <div>show condition one</div>
+  </template>
+  <template lwc:elseif="{conditionTwo}">
+    <div>show condition two</div>
+  </template>
+  <template lwc:else>
+    <div>show default condition</div>
+  </template>
+</template>
+```
+
+`after.html`:
+
+```html
+<template>
+  <template if:true="{conditionOne}">
+    <div>show condition one</div>
+  </template>
+  <template if:false="{conditionOne}">
+    <template if:true="{conditionTwo}">
+      <div>show condition two</div>
+    </template>
+    <template if:false="{conditionTwo}">
+      <div>show default condition</div>
+    </template>
+  </template>
+</template>
+```
+
+The proper review feedback for the example above:
+
+- replace `lwc:if={conditionOne}` with `if:true={conditionOne}`
+- replace `lwc:elseif={conditionTwo}` with `if:false={conditionOne}`, then create a nested template with `if:true={conditionTwo}` wrapping the remainder of the component
+- replace `lwc:else` with `if:false={conditionTwo}`
+
+Rules to follow:
+
+- If no action is required, return an empty list. Do not return null or any other value — return an empty array.
+- Keep issues concise; avoid duplicated issues or unnecessary analysis for things that are not real violations.
+- Stick to the instructions for the specific reviewer in scope. Issues outside that scope will be analyzed by other reviewers.
+- For each violation, provide:
+  - The exact violation type as defined by the reviewer in scope.
+  - A description of why it is a problem in the context of mobile offline priming.
+  - An intent analysis explaining what the developer likely intended.
+  - A suggested action with concrete code-level remediation.
+- Do not make assumptions about other components that may be referenced.

package/skills/reviewing-lwc-mobile-offline/scripts/komaci.config.mjs

@@ -0,0 +1,18 @@
+// ESLint flat config for the Komaci offline static analyzer.
+// Applies the recommended ruleset from
+// @salesforce/eslint-plugin-lwc-graph-analyzer with the bundleAnalyzer
+// processor wired in via the recommended config.
+import lwcGraphAnalyzerPlugin from '@salesforce/eslint-plugin-lwc-graph-analyzer';
+
+const PLUGIN_NAME = '@salesforce/lwc-graph-analyzer';
+const RECOMMENDED = lwcGraphAnalyzerPlugin.configs.recommended;
+
+export default [
+  {
+    name: `config: ${PLUGIN_NAME}`,
+    plugins: {
+      [PLUGIN_NAME]: lwcGraphAnalyzerPlugin,
+    },
+    ...RECOMMENDED,
+  },
+];

package/skills/reviewing-lwc-mobile-offline/scripts/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "reviewing-lwc-mobile-offline-runner",
+  "private": true,
+  "description": "Pinned ESLint + Komaci plugin used by run-komaci.sh.",
+  "type": "module",
+  "dependencies": {
+    "@salesforce/eslint-plugin-lwc-graph-analyzer": "^1.1.0-beta.2",
+    "eslint": "^9.35.0"
+  }
+}

package/skills/reviewing-lwc-mobile-offline/scripts/run-komaci.sh

@@ -0,0 +1,69 @@
+#!/usr/bin/env bash
+#
+# Komaci offline static analysis runner
+#
+# Runs @salesforce/eslint-plugin-lwc-graph-analyzer against an LWC bundle
+# with the plugin's recommended ruleset and emits ESLint's JSON
+# formatter output on stdout.
+#
+# The plugin's `bundleAnalyzer` processor expects the JS file to live
+# next to its sibling HTML templates so the offline data graph can be
+# resolved across the bundle.
+#
+# Plugin + ESLint versions are pinned in scripts/package.json and
+# installed into scripts/node_modules on first run so the runner is
+# isolated from whatever versions the host project happens to ship.
+#
+# Usage:
+#   run-komaci.sh path/to/component.js
+#
+# Arguments:
+#   $1  Path to the LWC component's JS file (required). The component's
+#       sibling HTML templates must live in the same directory; the
+#       plugin discovers them automatically via the bundle processor.
+#
+# Environment:
+#   KOMACI_ESLINT_BIN   Override the eslint binary (default: scripts/node_modules/.bin/eslint)
+#
+# Output:
+#   ESLint --format json on stdout. Non-zero exit if eslint reports
+#   errors; the JSON is still emitted on stdout in either case.
+
+set -euo pipefail
+
+if [ $# -lt 1 ]; then
+  echo "Usage: $0 path/to/component.js" >&2
+  exit 2
+fi
+
+JS_PATH="$1"
+
+if [ ! -f "$JS_PATH" ]; then
+  echo "Error: $JS_PATH does not exist" >&2
+  exit 2
+fi
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+CONFIG_PATH="$SCRIPT_DIR/komaci.config.mjs"
+PLUGIN_DIR="$SCRIPT_DIR/node_modules/@salesforce/eslint-plugin-lwc-graph-analyzer"
+
+# Install the pinned ESLint + plugin versions on first run. We resolve
+# them from SCRIPT_DIR so Node ESM picks up the right copy regardless
+# of the caller's cwd or the host project's node_modules.
+if [ ! -d "$PLUGIN_DIR" ]; then
+  echo "Installing pinned Komaci runner deps in $SCRIPT_DIR ..." >&2
+  (cd "$SCRIPT_DIR" && npm install --no-fund --no-save --silent) >&2
+fi
+
+ESLINT="${KOMACI_ESLINT_BIN:-$SCRIPT_DIR/node_modules/.bin/eslint}"
+
+# Run eslint with the plugin's recommended config and emit JSON.
+# `--no-config-lookup` ignores any host-project ESLint config so only
+# the Komaci recommended ruleset applies; `--no-error-on-unmatched-pattern`
+# avoids hard failure if the component path is empty.
+$ESLINT \
+  --no-config-lookup \
+  --no-error-on-unmatched-pattern \
+  --config "$CONFIG_PATH" \
+  --format json \
+  "$JS_PATH"

package/skills/using-mobile-native-capabilities/SKILL.md

@@ -0,0 +1,182 @@
+---
+name: using-mobile-native-capabilities
+description: "Build a Salesforce LWC that uses native mobile device capabilities — barcode scanner, biometrics, location, NFC, calendar, contacts, document scanner, geofencing, AR space capture, app review, and payments. Use this skill when the user asks for an LWC that scans a barcode, captures a photo of a document, reads location or geofences, prompts for biometrics, reads/writes the device calendar or contacts, taps NFC, takes a payment, prompts for an app review, or scans an AR space. Also triggers on \"lightning/mobileCapabilities\", \"mobile capability\", \"Nimbus\", \"device capability\". Do not use for mobile offline / Komaci priming reviews (use `reviewing-lwc-mobile-offline`) or for picking generic Lightning base components (use a generic Lightning base components skill)."
+metadata:
+  version: "1.0"
+---
+<!-- adk-managed-skill -->
+
+# Using Mobile Native Capabilities
+
+The `lightning/mobileCapabilities` module exposes a set of factory functions
+that return service objects for native device features (barcode scanning,
+biometrics, location, etc.). Each service extends a common
+[BaseCapability](references/base-capability.md) with an `isAvailable()`
+method, so an LWC can degrade gracefully on surfaces where the capability is
+not present (desktop, mobile web).
+
+This skill routes an agent through (1) picking the right capability, (2)
+loading the authoritative type definitions, and (3) wiring the service into
+an LWC with the correct availability gating, error handling, and
+deprecation-aware API choice.
+
+## When to Use This Skill
+
+- User asks for an LWC that uses a device capability listed in the index
+  below.
+- User mentions `lightning/mobileCapabilities`, "mobile capability", or
+  "Nimbus" by name.
+- User wants to know which mobile native APIs are available, or which one
+  fits their feature.
+
+Do NOT use this skill for:
+
+- Mobile-offline review of an LWC (lwc:if, inline GraphQL, Komaci-priming
+  violations) — use `reviewing-lwc-mobile-offline`.
+- Picking generic Lightning Base Components — use
+  `using-lightning-base-components`.
+
+## Prerequisites
+
+- Knowledge that the LWC will run inside a supported mobile container
+  (Salesforce Mobile App, Field Service Mobile App). These capabilities are
+  unavailable on desktop and mobile web; gate every call behind
+  `isAvailable()`.
+- Familiarity with the `lightning/mobileCapabilities` module declaration
+  (see [mobile-capabilities](references/mobile-capabilities.md)).
+
+## Capability Index
+
+| Capability | Reference | One-line use |
+| --- | --- | --- |
+| App Review | [App Review](references/app-review.md) | Prompt the user for a native in-app review. |
+| AR Space Capture | [AR Space Capture](references/ar-space-capture.md) | Capture a 3D scan of a physical space using AR. |
+| Barcode Scanner | [Barcode Scanner](references/barcode-scanner.md) | Read QR / UPC / EAN / Code-128 / etc. from the camera. |
+| Biometrics | [Biometrics](references/biometrics.md) | Authenticate via Face ID / fingerprint. |
+| Calendar | [Calendar](references/calendar.md) | Read or create events on the device calendar. |
+| Contacts | [Contacts](references/contacts.md) | Read or create entries in the device address book. |
+| Document Scanner | [Document Scanner](references/document-scanner.md) | Scan paper documents using the camera with edge detection. |
+| Geofencing | [Geofencing](references/geofencing.md) | Trigger logic when the device crosses a geographic boundary. |
+| Location | [Location](references/location.md) | Read GPS coordinates and watch for updates. |
+| NFC | [NFC](references/nfc.md) | Read or write NFC tags. |
+| Payments | [Payments](references/payments.md) | Take an Apple Pay / Google Pay payment. |
+
+## Workflow
+
+### Step 1 — Identify the capability
+
+Map the user's feature ask to one row of the capability index. If the ask
+spans multiple capabilities (e.g. "scan a barcode and store it on a
+contact"), plan for **each** capability separately — there is one factory
+function per capability.
+
+### Step 2 — Load the shared and capability-specific references
+
+Read these two shared references **once** per session — they apply to every
+capability and are not duplicated in the per-capability files:
+
+- [BaseCapability](references/base-capability.md) — the common interface
+  with `isAvailable()` that every service extends.
+- [mobile-capabilities](references/mobile-capabilities.md) — the
+  `lightning/mobileCapabilities` module declaration showing every
+  re-exported service.
+
+Then open the capability's reference file from the table above. Each
+per-capability reference contains the service-specific TypeScript API
+(factory function, service interface, options types, result types, error
+types) and assumes the two shared references above are already in context.
+
+Do not infer the API from memory — read it. The services evolve and some
+methods are explicitly `@deprecated` in favor of newer alternatives.
+
+### Step 3 — Wire the service into the LWC
+
+For each capability:
+
+1. Import the factory from `lightning/mobileCapabilities`:
+   ```js
+   import { getBarcodeScanner } from 'lightning/mobileCapabilities';
+   ```
+2. Get an instance: `const scanner = getBarcodeScanner();`
+3. Gate the call behind `isAvailable()`:
+   ```js
+   if (!scanner.isAvailable()) {
+     // graceful fallback or user message
+     return;
+   }
+   ```
+4. Call the **non-deprecated** entry point. Several services keep older
+   methods marked `@deprecated` alongside the recommended one — always
+   prefer the recommended method in the reference.
+5. Wrap the promise in `try/catch` and handle the typed failure codes the
+   service exposes (e.g. `BarcodeScannerFailureCode`,
+   `LocationServiceFailureCode`). User-cancelled vs. permission-denied vs.
+   service-unavailable are distinct UX states.
+
+### Step 4 — Surface failure modes to the user
+
+Each service defines its own failure-code enum. Translate codes into
+user-actionable messages: a `USER_DENIED_PERMISSION` should ask the user to
+grant permission; a `USER_DISABLED_PERMISSION` must direct them to the OS
+settings; a `SERVICE_NOT_ENABLED` should be a developer-visible error, not
+shown to the user.
+
+### Step 5 — Stay inside the supported surface
+
+Mobile capabilities are available **only** when the LWC runs inside a
+supported Salesforce mobile app. If the same component is rendered on
+desktop or mobile web, the factory will still return an object but
+`isAvailable()` will return `false`. Never assume availability — gate every
+call.
+
+
+## Examples
+
+### Example — "Scan a barcode and write it into a field"
+
+1. Map to: Barcode Scanner.
+2. Read [Barcode Scanner](references/barcode-scanner.md).
+3. Use `scan(options)` (not the deprecated `beginCapture` / `resumeCapture`
+   / `endCapture` triple).
+4. In options, set the `barcodeTypes` to the symbologies needed (default is
+   all supported types) and `enableMultiScan: false` for a single read.
+5. On resolve, write `result[0].value` to the bound field. On reject,
+   inspect `error.code` against `BarcodeScannerFailureCode`.
+
+### Example — "Take an Apple Pay payment for an order total"
+
+1. Map to: Payments.
+2. Read [Payments](references/payments.md).
+3. Gate on `isAvailable()`.
+4. Build the payment request object per the reference.
+5. On resolve, surface the transaction id to the calling flow. On reject,
+   handle user-cancelled and payment-failed paths separately.
+
+
+## Verification Checklist
+
+- [ ] Every capability call is preceded by `isAvailable()`.
+- [ ] The non-deprecated entry point is used (no `beginCapture` /
+      `resumeCapture` / `endCapture` for barcode, etc.).
+- [ ] Each rejection path is mapped to the typed failure code enum.
+- [ ] Imports come from `lightning/mobileCapabilities`, not from a private
+      path.
+- [ ] No assumption that the capability runs on desktop or mobile web.
+
+
+## Troubleshooting
+
+- **`isAvailable()` returns `false` on a real device** — the device is
+  running an unsupported app surface (not Salesforce Mobile or Field
+  Service Mobile), or the service is gated by an org-level setting. The
+  fix is org configuration, not code.
+- **TypeScript can't find the import** — confirm the LWC has access to
+  `lightning/mobileCapabilities`. The module is declared globally inside
+  Salesforce mobile containers; outside that, the types must be installed
+  separately.
+- **Deprecated barcode methods still work** — yes, but new code must use
+  `scan()` and `dismiss()`. Refactor any sample code the agent received
+  before returning it.
+- **Multiple capabilities in one component** — get separate instances per
+  capability (they are independent service objects); do not try to share
+  state between them.

package/skills/using-mobile-native-capabilities/references/app-review.md

@@ -0,0 +1,68 @@
+# App Review Service Grounding Context
+
+The following content provides grounding information for generating a Salesforce LWC that leverages app review facilities on mobile devices. Specifically, this context will cover the API types and methods available to leverage the app review API of the mobile device, within the LWC.
+
+## App Review Service API
+
+```typescript
+/*
+ * Copyright (c) 2024, Salesforce, Inc.
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import { BaseCapability } from '../BaseCapability.js';
+
+/**
+ * Use this factory function to get an instance of {@linkcode AppReviewService}.
+ * @returns An instance of {@linkcode AppReviewService}.
+ */
+export function getAppReviewService(): AppReviewService;
+
+/**
+ * Request an app review from a Lightning web component.
+ * @see {@link https://developer.salesforce.com/docs/platform/lwc/guide/reference-lightning-appreviewservice.html|AppReviewService API}
+ */
+export interface AppReviewService extends BaseCapability {
+  /**
+   * Requests an app review.
+   * @param options An {@linkcode AppReviewServiceOptions} object to configure the {@linkcode AppReviewService} request.
+   * @returns A resolved promise returns null.
+   */
+  requestAppReview(options?: AppReviewServiceOptions): Promise<null>;
+}
+
+/**
+ * An object representing configuration details for an {@linkcode AppReviewService} session.
+ */
+export interface AppReviewServiceOptions {
+  /**
+   * Ignore the app review request if already asked for the current version of the app.
+   */
+  ignoreIfAlreadyRequestedForCurrentAppVersion: boolean;
+}
+
+/**
+ * An object representing an error that occurred when accessing {@linkcode AppReviewService} features.
+ */
+export interface AppReviewServiceFailure {
+  /**
+   * A value representing the reason for an app review error.
+   */
+  code: AppReviewServiceFailureCode;
+
+  /**
+   * A string value describing the reason for the failure. This value is suitable for use in user interface messages. The message is provided in English and isn’t localized.
+   */
+  message: string;
+}
+
+/**
+ * Possible failure codes.
+ */
+type AppReviewServiceFailureCode =
+  | 'ALREADY_REQUESTED_FOR_CURRENT_APP_VERSION'
+  | 'IN_APP_REVIEW_ERROR'
+  | 'SERVICE_NOT_ENABLED'
+  | 'UNKNOWN_REASON';
+```

package/skills/using-mobile-native-capabilities/references/ar-space-capture.md

@@ -0,0 +1,125 @@
+# AR Space Capture Service Grounding Context
+
+The following content provides grounding information for generating a Salesforce LWC that leverages AR Space Capture facilities on mobile devices. Specifically, this context will cover the API types and methods available to leverage the AR Space Capture API of the mobile device, within the LWC.
+
+## AR Space Capture Service API
+
+```typescript
+/*
+ * Copyright (c) 2024, Salesforce, Inc.
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import { BaseCapability } from '../BaseCapability.js';
+
+/**
+ * Use this factory function to get an instance of {@linkcode ARSpaceCapture}.
+ * @returns An instance of {@linkcode ARSpaceCapture}.
+ */
+export function getARSpaceCapture(): ARSpaceCapture;
+
+/**
+ * Scan a room using Apple's RoomPlan AR Capabilities.
+ */
+export interface ARSpaceCapture extends BaseCapability {
+  /**
+   * Scan Room using Apple's AR Capabilities.
+   * @param options The customization options for the {@linkcode ARSpaceCapture} Plugin.
+   * @returns A resolved promise returns {@linkcode ARSpaceCaptureResult} object.
+   */
+  scanRoom(options?: ARSpaceCaptureOptions): Promise<ARSpaceCaptureResult>;
+}
+
+/**
+ * ARSpaceCaptureResult interface.
+ */
+export interface ARSpaceCaptureResult {
+  capturedRooms: CapturedRoom[] | null;
+}
+
+/**
+ * CapturedRoom interface.
+ */
+export interface CapturedRoom {
+  /**
+   * An array of walls that the framework identifies during a scan.
+   */
+  walls: unknown[];
+
+  /**
+   * An array of doors that the framework identifies during a scan.
+   */
+  doors: unknown[];
+
+  /**
+   * An array of windows that the framework identifies during a scan.
+   */
+  windows: unknown[];
+
+  /**
+   * An array of openings that the framework identifies during a scan.
+   */
+  openings: unknown[];
+
+  /**
+   * An array of floors that the framework identifies during a scan.
+   * Available iOS 17.0+.
+   */
+  floors: unknown[];
+
+  /**
+   * An array of objects that the framework identifies during a scan.
+   */
+  objects: unknown[];
+
+  /**
+   * A unique alphanumeric value that the framework assigns the room.
+   */
+  identifier: string;
+
+  /**
+   * One or more room types that the framework observes in the room.
+   * Available iOS 17.0+.
+   */
+  sections: unknown[];
+
+  /**
+   * The story, floor number, or level on which the captured room resides within a larger structure.
+   * Available iOS 17.0+.
+   */
+  story: number;
+
+  /**
+   * A version number for the captured room.
+   * Available iOS 17.0+.
+   */
+  version: number;
+}
+
+/**
+ * ARSpaceCaptureOptions interface.
+ */
+export interface ARSpaceCaptureOptions {
+  permissionRationaleText?: string;
+  presentWithAnimation: boolean;
+}
+
+/**
+ * ARSpaceCaptureFailure interface.
+ */
+export interface ARSpaceCaptureFailure {
+  code: ARSpaceCaptureFailureCode;
+  message: string;
+}
+
+/**
+ * Possible failure codes.
+ */
+type ARSpaceCaptureFailureCode =
+  | 'USER_DISMISSED' // User cancelled the operation.
+  | 'USER_DENIED_PERMISSION' // The user denied permissions to use the device camera.
+  | 'AR_NOT_SUPPORTED' // The AR capabilities are not enabled/available on the device.
+  | 'SERVICE_NOT_ENABLED' // The service is not enabled and therefore cannot be used.
+  | 'UNKNOWN_REASON'; // An error happened in the native code that is not permission based. Will give more information in the ARSpaceCaptureFailure message
+```