@uipath/skills 1.196.0 → 1.197.0

package/skills/uipath-coded-apps/references/widgets/validation-station.md

@@ -0,0 +1,308 @@
+# Validation Station Widget
+
+React wrapper around the UiPath Document Understanding **Validation Station** web component. Use when the app must let a human review and correct extraction results from a DU document.
+
+Package: [`@uipath/ui-widgets-validation-station`](https://www.npmjs.com/package/@uipath/ui-widgets-validation-station). Full prop/API surface lives in the package README — this file covers only the integration steps that are easy to get wrong inside a Coded App.
+
+## When to Use
+
+- User asks to **validate, review, correct, or approve** Document Understanding extraction results.
+- App receives a `ContentValidationData` payload (bucket paths + document ID) — either from an Action Center task created by a DU workflow, or fetched at runtime in a web app.
+- Replaces a hand-rolled PDF viewer + field editor. Do **not** rebuild this UI from scratch — the widget already handles PDF rendering, bounding boxes, table editing, translations, and save/discard plumbing.
+
+If the user just wants a generic form (no DU document), use the standard Action App form pattern in [../create-action-app.md](../create-action-app.md) instead.
+
+## Critical Rules
+
+1. **Peer versions are hard requirements.** Widget requires `react >= 19.2.0`, `react-dom >= 19.2.0`, `@uipath/uipath-typescript >= 1.4.1`. The Vite scaffold pins React 19.2+, but verify in `package.json` before installing.
+2. **Copy `du-assets/` into build output.** The underlying web component loads PDF.js worker, cmaps, wasm, and i18n from a sibling `du-assets/` directory resolved via `import.meta.url`. Without this, **PDF rendering and translations silently 404 in production** — no build error. See "Static assets" below.
+3. **Set `optimizeDeps.exclude: ['@uipath/du-validation-station-wc']` in `vite.config.ts`.** Vite's pre-bundler rewrites `import.meta.url` and breaks runtime asset resolution.
+4. **Body needs `light` or `dark` class** for theming. Match it to the `theme` prop. Action apps already manage this via `onInitTheme` from `CodedActionAppService.getTask()`.
+5. **`sdk` must already be initialized.** Pass the same `UiPath` instance produced by `useAuth()` (web app) or constructed in `src/uipath.ts` (action app). Do not construct a second SDK just for the widget — auth state will diverge.
+6. **Required SDK scopes:** `OR.Buckets` (the widget fetches the document and extraction artifacts from a storage bucket). Add `OR.Tasks` as well when the widget is rendered inside an Action Center task (action app, or web app that completes a task on save). Add to the `scope` field in `uipath.json` before first run; mismatch fails silently with 401/403. See [../oauth-scopes.md](../oauth-scopes.md).
+7. **Widget does NOT surface failures.** `onSubmitComplete` / `onSaveAsDraftComplete` fire with `{ success: false, error }` on failure but render no toast — the host owns all UI feedback (toast, retry, log). Wire these callbacks or failures are silent.
+8. **Report-as-exception makes no API call.** `onReportExceptionComplete(documentId, reason)` only hands the host the data — it does NOT persist. The host must call `OrchestratorDuModule.submitExceptionReport(taskId, documentId, reason, { folderId })` itself, or the user's "Report as exception" click is a no-op. Needs `OR.Tasks`.
+
+## Install
+
+From inside the scaffolded app directory:
+
+```bash
+npm install @uipath/ui-widgets-validation-station --@uipath:registry=https://registry.npmjs.org
+```
+
+Registry flag forces the public npm registry (skill default — users may have `@uipath` scoped to GitHub Packages).
+
+## Static Assets — Vite Plugin
+
+Replace `vite.config.ts` with the full file below. The plugin runs after `build` and copies the WC's `du-assets/` next to the emitted JS chunks:
+
+```typescript
+import react from '@vitejs/plugin-react';
+import { cp } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { dirname, resolve } from 'node:path';
+import { defineConfig, type Plugin } from 'vite';
+
+const require = createRequire(import.meta.url);
+
+function copyDuValidationStationAssets(): Plugin {
+  let destDir = '';
+  return {
+    name: 'copy-du-validation-station-assets',
+    apply: 'build',
+    configResolved(config) {
+      destDir = resolve(
+        config.root,
+        config.build.outDir,
+        config.build.assetsDir,
+        'du-assets',
+      );
+    },
+    async closeBundle() {
+      const wcRoot = dirname(
+        require.resolve('@uipath/du-validation-station-wc/package.json'),
+      );
+      await cp(resolve(wcRoot, 'du-assets'), destDir, { recursive: true });
+    },
+  };
+}
+
+export default defineConfig({
+  plugins: [react(), copyDuValidationStationAssets()],
+  base: './',
+  optimizeDeps: {
+    exclude: ['@uipath/du-validation-station-wc'],
+  },
+});
+```
+
+Verify after `npm run build`: `ls dist/assets/du-assets/` must list `pdfjs/`, `cmaps/`, `wasm/`, `i18n/`. Empty or missing → plugin did not run.
+
+## Key Props
+
+Full table in the package README. Inside a coded app you usually only touch:
+
+| Prop | Required | Notes |
+|------|----------|-------|
+| `sdk` | Yes | `UiPath` instance — from `useAuth()` or `src/uipath.ts`. Must be initialized. |
+| `data` | Yes | `ContentValidationData` — for action apps, this comes from the task payload. For web apps, fetch and pass yourself. |
+| `folderId` | No* | Falls back to `data.FolderId`. One of the two must resolve to a value or the widget errors — pass explicitly when the payload omits it. |
+| `theme` | No | `'light' \| 'dark' \| 'light-hc' \| 'dark-hc'`. Keep in sync with body class. |
+| `language` | No | `ValidationStationLanguage` enum exported from the package (e.g. `English`, `German`, `Japanese`, `ChineseSimplified`). |
+| `isReadonly` | No | `true` to render in read-only mode (e.g., audit view). |
+| `options` | No | `IValidationStationOptions` — fine-grained WC feature flags. Set `emitDtoStateChanges: true` to enable save-as-draft. |
+| `save` | No | Controlled trigger from a button. `{ validate: true }` = **submit** (validate, then save). `{ validate: false }` = **save as draft** (requires `options.emitDtoStateChanges: true`, else no-op). |
+| `discardChanges` | No | Controlled trigger: `{ value: true }` to discard pending edits. Pass a fresh object each time — the widget watches for the new reference, so repeated `{ value: true }` calls all fire. |
+| `onSubmitComplete` | No | Fires after **submit** (`save={{ validate: true }}`): ProcessExtractedData + bucket upload. Receives `SaveValidatedDataResult`. Use to complete the task with the approve action. |
+| `onSaveAsDraftComplete` | No | Fires after **save as draft** (`save={{ validate: false }}`): uploads in-progress data, no ProcessExtractedData. Receives `SaveValidatedDataResult`. |
+| `onReportExceptionComplete` | No | Fires when the user reports an exception. Signature `(documentId, reason)`, **not** `SaveValidatedDataResult`. Widget makes **no API call** — host must persist via `OrchestratorDuModule.submitExceptionReport(...)`. |
+
+The widget surfaces three flows. **Submit** and **save as draft** are owned end-to-end by the widget and hand the host a `SaveValidatedDataResult` — `{ success: true }` or `{ success: false, error: string }`. **Report as exception** is forwarded to the host as raw `(documentId, reason)` strings with no API call. The widget renders no failure UI for any flow — handle `success: false` in the callback yourself (toast, retry, log).
+
+## Integration: Action App (most common)
+
+Validation Station as the form inside an Action Center DU validation task. Replaces `src/components/Form.tsx` from the standard action-app scaffold.
+
+```typescript
+// src/components/Form.tsx
+import { useState, useEffect, useCallback } from 'react';
+import {
+  ValidationStation,
+  ValidationStationLanguage,
+  type SaveValidatedDataResult,
+} from '@uipath/ui-widgets-validation-station';
+import type { DuFramework } from '@uipath/uipath-typescript/document-understanding';
+import { OrchestratorDuModule } from '@uipath/uipath-typescript/orchestrator-du-module';
+import { MessageSeverity, Theme } from '@uipath/coded-action-app';
+import { sdk, codedActionAppService } from '../uipath';
+
+const isDarkTheme = (t: Theme) =>
+  t === Theme.Dark || t === Theme.DarkHighContrast;
+
+interface FormProps {
+  onInitTheme: (isDark: boolean) => void;
+}
+
+function Form({ onInitTheme }: FormProps) {
+  const [data, setData] = useState<DuFramework.ContentValidationData | null>(null);
+  const [taskId, setTaskId] = useState<number | undefined>(undefined);
+  const [folderId, setFolderId] = useState<number | undefined>(undefined);
+  const [theme, setTheme] = useState<'light' | 'dark'>('light');
+  const [isReadonly, setIsReadonly] = useState(false);
+  const [save, setSave] = useState<{ validate: boolean } | undefined>(undefined);
+
+  useEffect(() => {
+    codedActionAppService.getTask().then((task) => {
+      // task.data is typed `unknown`; the payload is ContentValidationData
+      setData(task.data as DuFramework.ContentValidationData);
+      setTaskId(task.taskId);
+      setFolderId(task.folderId);
+      setIsReadonly(task.isReadOnly);
+      const dark = isDarkTheme(task.theme);
+      setTheme(dark ? 'dark' : 'light');
+      onInitTheme(dark);
+    });
+  }, [onInitTheme]);
+
+  // Submit succeeded → approve the task. Widget shows no error toast — handle failure here.
+  const handleSubmitComplete = useCallback(
+    async (result: SaveValidatedDataResult) => {
+      if (!result.success) {
+        codedActionAppService.showMessage(result.error, MessageSeverity.Error);
+        return;
+      }
+      await codedActionAppService.completeTask('Approve', {});
+    },
+    [],
+  );
+
+  // Report-as-exception is not persisted by the widget — call the SDK, then reject the task.
+  const handleReportException = useCallback(
+    async (documentId: string, reason: string) => {
+      if (taskId === undefined) return;
+      const response = await new OrchestratorDuModule(sdk).submitExceptionReport(
+        taskId,
+        documentId,
+        reason || 'Reported via Validation Station',
+        { folderId },
+      );
+      if (!response.IsSuccessful) {
+        codedActionAppService.showMessage(
+          response.ErrorMessage ?? 'Failed to report exception',
+          MessageSeverity.Error,
+        );
+        return;
+      }
+      await codedActionAppService.completeTask('Reject', {});
+    },
+    [taskId, folderId],
+  );
+
+  if (!data) return null; // wait for task payload
+
+  return (
+    <>
+      <button type="button" onClick={() => setSave({ validate: true })} disabled={isReadonly}>
+        Validate &amp; submit
+      </button>
+      <ValidationStation
+        sdk={sdk}
+        data={data}
+        folderId={folderId}
+        theme={theme}
+        language={ValidationStationLanguage.English}
+        isReadonly={isReadonly}
+        save={save}
+        onSubmitComplete={handleSubmitComplete}
+        onReportExceptionComplete={handleReportException}
+      />
+    </>
+  );
+}
+
+export default Form;
+```
+
+Adjust `src/uipath.ts` to export the initialized `sdk` alongside `codedActionAppService`:
+
+```typescript
+import { UiPath } from '@uipath/uipath-typescript/core';
+import { CodedActionAppService } from '@uipath/coded-action-app';
+
+export const sdk = new UiPath();
+await sdk.initialize();
+export const codedActionAppService = new CodedActionAppService();
+```
+
+`action-schema.json` for a DU validation task typically has no `inputs`/`outputs` — the widget owns the data contract. A minimal schema:
+
+```json
+{
+  "inputs":  { "type": "object", "properties": {} },
+  "outputs": { "type": "object", "properties": {} },
+  "inOuts":  { "type": "object", "properties": {} },
+  "outcomes": {
+    "type": "object",
+    "properties": {
+      "Approve": { "type": "string" },
+      "Reject":  { "type": "string" }
+    }
+  }
+}
+```
+
+## Integration: Web App
+
+Same widget, sdk comes from `useAuth()`. Typical flow: list `TaskType.DocumentValidation` tasks with `tasks.getAll(...)`, **then hydrate the selected row with `tasks.getById(...)` to load `task.data`** — `getAll()` returns task summaries without `data` populated, so passing a `getAll` row straight into the widget produces an empty viewer.
+
+```typescript
+import { useEffect, useMemo, useState } from 'react';
+import {
+  ValidationStation,
+  ValidationStationLanguage,
+  type SaveValidatedDataResult,
+} from '@uipath/ui-widgets-validation-station';
+import type { DuFramework } from '@uipath/uipath-typescript/document-understanding';
+import { Tasks, TaskType } from '@uipath/uipath-typescript/tasks';
+import type { TaskGetResponse } from '@uipath/uipath-typescript/tasks';
+import { useAuth } from '../hooks/useAuth';
+
+function ValidatePage({ taskId, folderId }: { taskId: number; folderId: number }) {
+  const { sdk } = useAuth();
+  const tasks = useMemo(() => new Tasks(sdk), [sdk]);
+  const [selectedTask, setSelectedTask] = useState<TaskGetResponse | null>(null);
+
+  // getAll() rows don't carry `data` — fetch the full task by id.
+  useEffect(() => {
+    tasks.getById(taskId, { taskType: TaskType.DocumentValidation }, folderId).then(setSelectedTask);
+  }, [tasks, taskId, folderId]);
+
+  const handleSubmitComplete = async (result: SaveValidatedDataResult) => {
+    if (!result.success || !selectedTask) return; // widget renders no error UI — surface it yourself
+    await selectedTask.complete({
+      action: 'Completed',
+      type: TaskType.DocumentValidation,
+    });
+  };
+
+  if (!selectedTask) return null;
+
+  return (
+    <ValidationStation
+      sdk={sdk}
+      data={selectedTask.data as DuFramework.ContentValidationData}
+      folderId={selectedTask.folderId}
+      theme="light"
+      language={ValidationStationLanguage.English}
+      onSubmitComplete={handleSubmitComplete}
+    />
+  );
+}
+
+export default ValidatePage;
+```
+
+Two things to lock in:
+
+- **Always call `tasks.getById(id, { taskType: TaskType.DocumentValidation }, folderId)` before rendering the widget.** Even if you already have a `TaskGetResponse` from `getAll()`, its `data` field is undefined. Re-fetch by id.
+- **DU validation tasks are `TaskType.DocumentValidation`** — do not pass `TaskType.Form`, `App`, or `External`. The action string for a successful validation is `"Completed"`. Prefer the task-attached `selectedTask.complete(...)` over the service-level `tasks.complete(...)` — no `taskId`/`folderId` to thread through. See [../sdk/action-center.md](../sdk/action-center.md) for the broader Tasks API.
+
+Body theme class — toggle on the document body (e.g., from `useAuth` user preferences or a theme switcher):
+
+```typescript
+useEffect(() => {
+  document.body.classList.toggle('dark', isDark);
+  document.body.classList.toggle('light', !isDark);
+}, [isDark]);
+```
+
+## Anti-patterns
+
+- **Do not skip the `du-assets/` copy step.** PDF rendering and translations 404 silently in prod; "works on my machine" because dev serves from `node_modules`.
+- **Do not construct a second `UiPath` SDK** for the widget. Reuse the app's authenticated instance.
+- **Do not call `setTaskData` and try to drive a custom form alongside the widget.** The widget owns the data contract end-to-end; mixing produces stale state and double saves.
+- **Do not pass a `tasks.getAll()` row straight into the widget.** `getAll()` rows omit `data` — the viewer renders empty. Hydrate with `tasks.getById(id, { taskType: TaskType.DocumentValidation }, folderId)` first.
+- **Do not call `completeTask` inside the `save` setter.** Always wait for `onSubmitComplete` with `success: true` — submit may fail validation, and completing early submits unvalidated data.
+- **Do not assume the widget shows an error on failure — it does not.** `onSubmitComplete`/`onSaveAsDraftComplete` with `success: false` render no UI; surface the error yourself (`showMessage`, toast, etc.).
+- **Do not treat `onReportExceptionComplete` like the save callbacks.** It receives `(documentId, reason)`, not `SaveValidatedDataResult`, and persists nothing — you must call `OrchestratorDuModule.submitExceptionReport(...)` before completing the task.

package/skills/uipath-coded-apps/scripts/validate-action-schema.js

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+/**
+ * Validate a UiPath Coded Action App `action-schema.json`.
+ *
+ * Single source of truth for action-schema rules in this skill. Mirrors the
+ * authoritative validator shipped in the UiPath CLI:
+ *   packages/codedapp-tool/src/types/action-app.ts  (JsonActionSchemaValidator)
+ *
+ * Do NOT restate the type / format / nesting rules in prose elsewhere in the
+ * skill — point at this script and run it instead.
+ *
+ * Node-only (no dependencies). Node is already a skill prerequisite.
+ *
+ * Usage:
+ *     node validate-action-schema.js <path/to/action-schema.json>
+ *     node validate-action-schema.js -        # read JSON from stdin
+ *     node validate-action-schema.js --show-types
+ *
+ * Exit codes:
+ *     0  valid
+ *     1  invalid  (one `path: message` per line on stderr)
+ *     2  usage / IO / JSON-parse error
+ *
+ * Extending with a new field type (future-proofing):
+ *     1. Add the JSON type name to SUPPORTED_TYPES.
+ *     2. Add its System.* mapping to TYPE_SYSTEM_MAP (informational — mirrors the
+ *        CLI's mapJsonTypeToSystemType; surfaced by --show-types).
+ *     3. If it introduces a new `format`, add it to SUPPORTED_FORMATS (and, if the
+ *        format may attach to a type other than `string`, extend
+ *        FORMAT_ALLOWED_TYPES).
+ *     The recursive property validator reads these tables — no other code changes.
+ */
+
+'use strict';
+
+const fs = require('fs');
+
+// --- Extensibility tables (keep in sync with the CLI enums) -----------------
+
+// JsonDataType
+const SUPPORTED_TYPES = ['string', 'integer', 'number', 'boolean', 'array', 'object', 'file'];
+
+// JsonFormatType
+const SUPPORTED_FORMATS = ['uuid', 'date'];
+
+// Which field types each format may attach to. The CLI allows format only on
+// `string` (uuid -> System.Guid, date -> System.DateOnly are string-encoded).
+const FORMAT_ALLOWED_TYPES = {
+  uuid: ['string'],
+  date: ['string'],
+};
+
+// Informational: JsonDataType -> System.* type the CLI maps to. Not enforced;
+// documents the runtime contract and powers --show-types.
+const TYPE_SYSTEM_MAP = {
+  string: 'System.String',
+  integer: 'System.Int64',
+  number: 'System.Decimal',
+  boolean: 'System.Boolean',
+  object: 'System.Object',
+  file: 'UiPath.Platform.ResourceHandling.IResource',
+  // `array` is a collection wrapper around its `items` type, not a System.* leaf.
+};
+
+const SECTIONS = ['inputs', 'outputs', 'inOuts', 'outcomes'];
+
+// --- Validation -------------------------------------------------------------
+
+function isPlainObject(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function createErrors() {
+  const errors = [];
+  errors.add = (path, message) => errors.push(`  - ${path}: ${message}`);
+  return errors;
+}
+
+function validateProperty(prop, path, errors) {
+  if (!isPlainObject(prop)) {
+    errors.add(path, 'property must be an object');
+    return;
+  }
+
+  const ptype = prop.type;
+  if (!SUPPORTED_TYPES.includes(ptype)) {
+    errors.add(
+      `${path}.type`,
+      `type must be one of: ${SUPPORTED_TYPES.join(', ')} (got ${JSON.stringify(ptype)})`
+    );
+    // Can't reason further about a bad type.
+    return;
+  }
+
+  if ('required' in prop && typeof prop.required !== 'boolean') {
+    errors.add(`${path}.required`, 'required must be a boolean');
+  }
+
+  if ('description' in prop && typeof prop.description !== 'string') {
+    errors.add(`${path}.description`, 'description must be a string');
+  }
+
+  const fmt = prop.format;
+  if (fmt !== undefined && fmt !== null) {
+    if (!SUPPORTED_FORMATS.includes(fmt)) {
+      errors.add(
+        `${path}.format`,
+        `format must be one of: ${SUPPORTED_FORMATS.join(', ')} (got ${JSON.stringify(fmt)})`
+      );
+    } else if (!(FORMAT_ALLOWED_TYPES[fmt] || []).includes(ptype)) {
+      errors.add(
+        `${path}.format`,
+        `'${fmt}' format is only allowed on type ` +
+          `${(FORMAT_ALLOWED_TYPES[fmt] || []).join(' / ')} (type is '${ptype}')`
+      );
+    }
+  }
+
+  // Arrays: items required; nested arrays disallowed.
+  if (ptype === 'array') {
+    const items = prop.items;
+    if (items === undefined || items === null) {
+      errors.add(`${path}.items`, "array type requires an 'items' definition");
+    } else {
+      if (isPlainObject(items) && items.type === 'array') {
+        errors.add(
+          `${path}.items.type`,
+          "nested arrays are not supported (an array's items.type cannot be 'array')"
+        );
+      }
+      validateProperty(items, `${path}.items`, errors);
+    }
+  }
+
+  // Validate nested object/array-of-object properties.
+  const props = prop.properties;
+  if (props !== undefined && props !== null) {
+    if (!isPlainObject(props)) {
+      errors.add(`${path}.properties`, 'properties must be an object');
+    } else {
+      for (const [childName, child] of Object.entries(props)) {
+        validateProperty(child, `${path}.properties.${childName}`, errors);
+      }
+    }
+  }
+}
+
+function validateSection(schema, name, errors) {
+  if (!(name in schema)) {
+    errors.add(name, 'missing required section');
+    return;
+  }
+  const section = schema[name];
+  if (!isPlainObject(section)) {
+    errors.add(name, 'section must be an object');
+    return;
+  }
+  if (section.type !== 'object') {
+    errors.add(`${name}.type`, 'section "type" must be the literal "object"');
+  }
+  const props = section.properties;
+  if (props === undefined || props === null) {
+    errors.add(`${name}.properties`, "section must have a 'properties' object (use {} when empty)");
+  } else if (!isPlainObject(props)) {
+    errors.add(`${name}.properties`, "section 'properties' must be an object");
+  } else {
+    for (const [fieldName, field] of Object.entries(props)) {
+      validateProperty(field, `${name}.properties.${fieldName}`, errors);
+    }
+  }
+}
+
+/** Return a list of error strings. Empty list == valid. */
+function validateActionSchema(schema) {
+  const errors = createErrors();
+  if (!isPlainObject(schema)) {
+    errors.add('root', 'action-schema must be a JSON object');
+    return errors;
+  }
+  for (const name of SECTIONS) {
+    validateSection(schema, name, errors);
+  }
+  return errors;
+}
+
+// --- CLI --------------------------------------------------------------------
+
+function readStdin() {
+  return fs.readFileSync(0, 'utf8');
+}
+
+function main(argv) {
+  if (argv.includes('--show-types')) {
+    process.stdout.write('Supported field types:\n');
+    for (const t of SUPPORTED_TYPES) {
+      const mapped = TYPE_SYSTEM_MAP[t] || '(collection of items type)';
+      process.stdout.write(`  ${t.padEnd(8)} -> ${mapped}\n`);
+    }
+    process.stdout.write(`Supported formats (string only): ${SUPPORTED_FORMATS.join(', ')}\n`);
+    return 0;
+  }
+
+  const args = argv.filter((a) => !a.startsWith('-'));
+  if (args.length !== 1 && !(argv.length === 1 && argv[0] === '-')) {
+    process.stderr.write('usage: validate-action-schema.js <action-schema.json | ->\n');
+    return 2;
+  }
+
+  const source = argv.length ? argv[0] : '-';
+  let raw;
+  try {
+    raw = source === '-' ? readStdin() : fs.readFileSync(source, 'utf8');
+  } catch (exc) {
+    process.stderr.write(`cannot read ${source}: ${exc.message}\n`);
+    return 2;
+  }
+
+  let schema;
+  try {
+    schema = JSON.parse(raw);
+  } catch (exc) {
+    process.stderr.write(`invalid JSON: ${exc.message}\n`);
+    return 2;
+  }
+
+  const errors = validateActionSchema(schema);
+  if (errors.length) {
+    process.stderr.write('Invalid action-schema.json:\n');
+    process.stderr.write(errors.join('\n') + '\n');
+    return 1;
+  }
+
+  process.stdout.write('action-schema.json is valid.\n');
+  return 0;
+}
+
+if (require.main === module) {
+  process.exit(main(process.argv.slice(2)));
+}
+
+module.exports = { validateActionSchema, SUPPORTED_TYPES, SUPPORTED_FORMATS };