From 448915aadfac8abcfad44316e935a2528a0e4f16 Mon Sep 17 00:00:00 2001
From: ken-werner-sp <ken.werner@sailpoint.com>
Date: Wed, 1 Apr 2026 21:48:24 -0700
Subject: [PATCH 1/4] POC of XPath Evaluator

This is a POC for the frontend of an XPath Evaluator tool, based entirely on the existing JSON Path Evaluator. Default values are a fake generated WorkDay result and XPath query for LastName. Relies upon a Lambda for XPath parsing. Errors are minimally exposed and will primarily result in a lack of output.
---
 docusaurus.config.ts                          |   4 +-
 navbar.ts                                     |   1 +
 .../xpath/ImplementationDropdown/index.tsx    | 112 +++++++++
 src/components/xpath/InputTerminal/index.tsx  |  64 +++++
 src/components/xpath/ResultTerminal/index.tsx |  54 ++++
 .../xpath/TerminalFontSizeDropdown/index.tsx  | 114 +++++++++
 .../xpath/XPathQueryInput/index.tsx           |  69 ++++++
 src/components/xpath/XPathRootInput/index.tsx |  69 ++++++
 src/components/xpath/useDebounce.ts           |  16 ++
 src/pages/tools/EscapeTool.module.css         |  12 +-
 src/pages/tools/sample.xml.json               |   1 +
 src/pages/tools/xpath-evaluator.tsx           | 233 ++++++++++++++++++
 src/pages/tools/xpath.module.css              |  96 ++++++++
 src/services/XPathService.ts                  |  58 +++++
 14 files changed, 896 insertions(+), 7 deletions(-)
 create mode 100644 src/components/xpath/ImplementationDropdown/index.tsx
 create mode 100644 src/components/xpath/InputTerminal/index.tsx
 create mode 100644 src/components/xpath/ResultTerminal/index.tsx
 create mode 100644 src/components/xpath/TerminalFontSizeDropdown/index.tsx
 create mode 100644 src/components/xpath/XPathQueryInput/index.tsx
 create mode 100644 src/components/xpath/XPathRootInput/index.tsx
 create mode 100644 src/components/xpath/useDebounce.ts
 create mode 100644 src/pages/tools/sample.xml.json
 create mode 100644 src/pages/tools/xpath-evaluator.tsx
 create mode 100644 src/pages/tools/xpath.module.css
 create mode 100644 src/services/XPathService.ts

diff --git a/docusaurus.config.ts b/docusaurus.config.ts
index 90298169e6dbe..7bbd7d58ed350 100644
--- a/docusaurus.config.ts
+++ b/docusaurus.config.ts
@@ -86,7 +86,9 @@ const config: Config = {
       { name: 'twitter:image', content: 'https://developer.sailpoint.com/img/SailPoint-Logo-OG.png' },
 
       // Content Security Policy
-      { 'http-equiv': 'Content-Security-Policy', content: "default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval' https://code.jquery.com https://www.googletagmanager.com https://cdn.jsdelivr.net https://cdn.cookielaw.org https://googleads.g.doubleclick.net; style-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net https://p.typekit.net https://use.typekit.net; img-src 'self' data: https: http:; font-src 'self' data: https://cdn.jsdelivr.net https://use.typekit.net https://cdnjs.cloudflare.com; connect-src 'self' http://localhost:3000 https://nug87yusrg.execute-api.us-east-1.amazonaws.com https://*.algolia.net https://*.algolianet.com https://www.googletagmanager.com https://www.google.com https://analytics.google.com https://developer.sailpoint.com https://cdn.cookielaw.org https://stats.g.doubleclick.net https://googleads.g.doubleclick.net https://*.api.identitynow.com https://*.api.identitynow-demo.com; frame-src 'self' https://www.googletagmanager.com https://www.youtube.com https://play.vidyard.com; worker-src 'self' blob:;" },
+      { 'http-equiv': 'Content-Security-Policy',
+ content: "default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval' https://code.jquery.com https://www.googletagmanager.com https://cdn.jsdelivr.net https://cdn.cookielaw.org https://googleads.g.doubleclick.net; style-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net https://p.typekit.net https://use.typekit.net; img-src 'self' data: https: http:; font-src 'self' data: https://cdn.jsdelivr.net https://use.typekit.net https://cdnjs.cloudflare.com; connect-src 'self' http://localhost:3000 https://nug87yusrg.execute-api.us-east-1.amazonaws.com https://o2352gowwy55a4vviyswr76lxu0ednjs.lambda-url.us-east-2.on.aws https://*.algolia.net https://*.algolianet.com https://www.googletagmanager.com https://www.google.com https://analytics.google.com https://developer.sailpoint.com https://cdn.cookielaw.org https://stats.g.doubleclick.net https://googleads.g.doubleclick.net https://*.api.identitynow.com https://*.api.identitynow-demo.com; frame-src 'self' https://www.googletagmanager.com https://www.youtube.com https://play.vidyard.com; worker-src 'self' blob:;" },
+
     ],
     algolia: {
       appId: 'TB01H1DFAM',
diff --git a/navbar.ts b/navbar.ts
index ae0c094a36995..795922cb1bdef 100644
--- a/navbar.ts
+++ b/navbar.ts
@@ -34,6 +34,7 @@ const navbarConfig = {
           { label: 'CLI', to: '/docs/tools/cli' },
           { label: 'Escaping Tool Formatter', to: '/tools/escaping-tool-formatter' },
           { label: 'JSON Path Evaluator', to: '/tools/json-path-evaluator' },
+          { label: 'XPath Evaluator', to: '/tools/xpath-evaluator' },
           { label: 'Rule Development Kit', to: '/docs/tools/rule-development-kit' },
           { label: 'UI Development Kit', to: '/docs/tools/ui-development-kit' },
           { label: 'Velocity PlayGround', to: '/tools/velocity-playground' },
diff --git a/src/components/xpath/ImplementationDropdown/index.tsx b/src/components/xpath/ImplementationDropdown/index.tsx
new file mode 100644
index 0000000000000..234420693703b
--- /dev/null
+++ b/src/components/xpath/ImplementationDropdown/index.tsx
@@ -0,0 +1,112 @@
+import React, { useState, FocusEvent, ChangeEvent } from 'react';
+import FormControl from '@mui/material/FormControl';
+import InputLabel from '@mui/material/InputLabel';
+import Select from '@mui/material/Select';
+import MenuItem from '@mui/material/MenuItem';
+import { useColorMode } from '@docusaurus/theme-common';
+import { createTheme, ThemeProvider } from '@mui/material/styles';
+
+// Define prop types
+interface ImplementationDropdownProps {
+  implementation: string;
+  onImplementationChange: (value: string) => void;
+  onFocus?: (event: FocusEvent<HTMLInputElement>) => void;
+  onBlur?: (event: FocusEvent<HTMLInputElement>) => void;
+}
+
+const ImplementationDropdown: React.FC<ImplementationDropdownProps> = ({
+  implementation,
+  onImplementationChange,
+  onFocus,
+  onBlur,
+}) => {
+  const { colorMode } = useColorMode();
+  const [isFocused, setIsFocused] = useState<boolean>(false);
+  const [expanded, setExpanded] = useState<boolean>(false);
+
+  const theme = createTheme({
+    components: {
+      MuiOutlinedInput: {
+        styleOverrides: {
+          root: {
+            '& .MuiOutlinedInput-notchedOutline': {
+              borderColor: colorMode === 'dark' ? '#ffffff' : 'initial',
+              borderWidth: 1,
+            },
+            '&.Mui-focused .MuiOutlinedInput-notchedOutline': {
+              borderColor: colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)',
+            },
+            '&:hover .MuiOutlinedInput-notchedOutline': {
+              borderColor: colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)',
+            },
+          },
+        },
+      },
+      MuiSelect: {
+        styleOverrides: {
+          icon: {
+            color: colorMode === 'dark' ? '#ffffff' : 'black',
+          },
+        },
+      },
+    },
+  });
+
+  const handleChange = (event: ChangeEvent<{ value: unknown }>) => {
+    onImplementationChange(event.target.value as string);
+  };
+
+  // Handle focus and blur state changes
+  const handleFocus = (event: FocusEvent<HTMLInputElement>) => {
+    setIsFocused(true);
+    if (onFocus) onFocus(event);
+  };
+
+  const handleBlur = (event: FocusEvent<HTMLInputElement>) => {
+    setIsFocused(false);
+    if (onBlur) onBlur(event);
+  };
+
+  // Handle dropdown expanded state
+  const handleDropdownOpen = () => setExpanded(true);
+  const handleDropdownClose = () => setExpanded(false);
+
+  return (
+    <ThemeProvider theme={theme}>
+      <FormControl sx={{ m: 1, minWidth: 220, maxWidth: 220 }}>
+        <InputLabel
+          id="implementation-dropdown-label"
+          sx={{
+            '&.Mui-focused': {
+              color: isFocused ? (colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)') : 'initial',
+            },
+          }}
+        >
+          Implementation
+        </InputLabel>
+
+        <Select
+          value={implementation}
+          onChange={handleChange}
+          onFocus={handleFocus}
+          onBlur={handleBlur}
+          label="Implementation"
+          labelId="implementation-dropdown-label"
+          id="implementation-dropdown-select"
+          onOpen={handleDropdownOpen}
+          onClose={handleDropdownClose}
+          aria-expanded={expanded}
+          sx={{
+            '& .MuiSelect-select': {
+              color: isFocused || expanded ? (colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)') : 'initial',
+            },
+          }}
+        >
+          <MenuItem value="XPath">XPath</MenuItem>
+        </Select>
+      </FormControl>
+    </ThemeProvider>
+  );
+};
+
+export default ImplementationDropdown;
diff --git a/src/components/xpath/InputTerminal/index.tsx b/src/components/xpath/InputTerminal/index.tsx
new file mode 100644
index 0000000000000..20906415062e2
--- /dev/null
+++ b/src/components/xpath/InputTerminal/index.tsx
@@ -0,0 +1,64 @@
+import React from 'react';
+import AceEditor from 'react-ace';
+import 'ace-builds/src-noconflict/mode-xml';
+import 'ace-builds/src-noconflict/mode-text';
+import 'ace-builds/src-noconflict/theme-github_dark';
+import 'ace-builds/src-noconflict/theme-github_light_default';
+import 'ace-builds/src-noconflict/ext-language_tools';
+import { useColorMode } from '@docusaurus/theme-common';
+import styles from '../../../pages/tools/xpath.module.css';
+
+// Ensure ace is properly configured
+declare const ace: any;
+if (typeof ace !== 'undefined' && ace.config) {
+  ace.config.setModuleUrl(
+    'ace/mode/json_worker',
+    new URL(
+      'https://ajaxorg.github.io/ace-builds/src-noconflict/worker-xml.js'
+    ).toString(),
+  );
+}
+
+interface InputTerminalProps {
+  fontSize: string;
+  value: string;
+  onChange: (value: string) => void;
+  hasJsonParseError?: boolean;
+  mode?: 'xml' | 'text'; // 🔄 new optional mode prop
+}
+
+const InputTerminal: React.FC<InputTerminalProps> = ({
+  fontSize,
+  value,
+  onChange,
+  hasJsonParseError = false,
+  mode = 'xml', // default to 'json' for backward compatibility
+}) => {
+  const { colorMode } = useColorMode();
+
+  const terminalClass = hasJsonParseError
+    ? styles.inputTerminalContainer
+    : styles.terminalContainerDefault;
+
+  return (
+    <div className="col">
+      <h2>Inputs</h2>
+      <AceEditor
+        className={terminalClass}
+        mode={mode}
+        theme={colorMode === 'dark' ? 'github_dark' : 'github_light_default'}
+        value={value}
+        onChange={onChange}
+        fontSize={`${fontSize}px`}
+        width="auto"
+        showPrintMargin={false}
+        editorProps={{ $blockScrolling: true }}
+        setOptions={{
+          fontFamily: 'monospace',
+        }}
+      />
+    </div>
+  );
+};
+
+export default InputTerminal;
diff --git a/src/components/xpath/ResultTerminal/index.tsx b/src/components/xpath/ResultTerminal/index.tsx
new file mode 100644
index 0000000000000..6ca944f2fe4f9
--- /dev/null
+++ b/src/components/xpath/ResultTerminal/index.tsx
@@ -0,0 +1,54 @@
+import React from 'react';
+import AceEditor from 'react-ace';
+import 'ace-builds/src-noconflict/mode-json';
+import 'ace-builds/src-noconflict/mode-text';
+import 'ace-builds/src-noconflict/theme-github_dark';
+import 'ace-builds/src-noconflict/theme-github_light_default';
+import 'ace-builds/src-noconflict/ext-language_tools';
+import { useColorMode } from '@docusaurus/theme-common';
+import styles from '../../../pages/tools/xpath.module.css';
+
+// Ensure ace is properly configured
+declare const ace: any;
+if (typeof ace !== 'undefined' && ace.config) {
+  ace.config.setModuleUrl(
+    'ace/mode/json_worker',
+    new URL(
+      'https://ajaxorg.github.io/ace-builds/src-noconflict/worker-json.js'
+    ).toString(),
+  );
+}
+
+// Props interface with optional `mode`
+interface ResultTerminalProps {
+  result: string;
+  fontSize: string;
+  mode?: 'json' | 'text';
+}
+
+const ResultTerminal: React.FC<ResultTerminalProps> = ({ result, fontSize, mode = 'json' }) => {
+  const { colorMode } = useColorMode();
+
+  return (
+    <div className="col" style={{ marginBottom: 50 }}>
+      <h2>Evaluation results</h2>
+
+      <AceEditor
+        className={styles.terminalContainerDefault}
+        mode={mode}
+        theme={colorMode === 'dark' ? 'github_dark' : 'github_light_default'}
+        value={result}
+        readOnly
+        fontSize={`${fontSize}px`}
+        width="auto"
+        showPrintMargin={false}
+        editorProps={{ $blockScrolling: true }}
+        setOptions={{
+          fontFamily: 'monospace',
+        }}
+      />
+    </div>
+  );
+};
+
+export default ResultTerminal;
diff --git a/src/components/xpath/TerminalFontSizeDropdown/index.tsx b/src/components/xpath/TerminalFontSizeDropdown/index.tsx
new file mode 100644
index 0000000000000..3188f2c2d3593
--- /dev/null
+++ b/src/components/xpath/TerminalFontSizeDropdown/index.tsx
@@ -0,0 +1,114 @@
+import React, { useState, ChangeEvent, FocusEvent } from 'react';
+import FormControl from '@mui/material/FormControl';
+import InputLabel from '@mui/material/InputLabel';
+import Select from '@mui/material/Select';
+import MenuItem from '@mui/material/MenuItem';
+import { createTheme, ThemeProvider } from '@mui/material/styles';
+import { useColorMode } from '@docusaurus/theme-common';
+
+// Define props interface
+interface TerminalFontSizeDropdownProps {
+  fontSize: string;
+  onFontSizeChange: (value: string) => void;
+  onFocus?: (event: FocusEvent<HTMLInputElement>) => void;
+  onBlur?: (event: FocusEvent<HTMLInputElement>) => void;
+}
+
+const TerminalFontSizeDropdown: React.FC<TerminalFontSizeDropdownProps> = ({
+  fontSize,
+  onFontSizeChange,
+  onFocus,
+  onBlur,
+}) => {
+  const { colorMode } = useColorMode();
+  const [isFocused, setIsFocused] = useState<boolean>(false);
+  const [expanded, setExpanded] = useState<boolean>(false);
+
+  const theme = createTheme({
+    components: {
+      MuiOutlinedInput: {
+        styleOverrides: {
+          root: {
+            '& .MuiOutlinedInput-notchedOutline': {
+              borderColor: colorMode === 'dark' ? '#ffffff' : 'initial',
+              borderWidth: 1,
+            },
+            '&.Mui-focused .MuiOutlinedInput-notchedOutline': {
+              borderColor: colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)',
+            },
+            '&:hover .MuiOutlinedInput-notchedOutline': {
+              borderColor: colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)',
+            },
+          },
+        },
+      },
+      MuiSelect: {
+        styleOverrides: {
+          icon: {
+            color: colorMode === 'dark' ? '#ffffff' : 'black',
+          },
+        },
+      },
+    },
+  });
+
+  const handleChange = (event: ChangeEvent<{ value: unknown }>) => {
+    onFontSizeChange(event.target.value as string);
+  };
+
+  // Handle focus and blur state changes
+  const handleFocus = (event: FocusEvent<HTMLInputElement>) => {
+    setIsFocused(true);
+    if (onFocus) onFocus(event);
+  };
+
+  const handleBlur = (event: FocusEvent<HTMLInputElement>) => {
+    setIsFocused(false);
+    if (onBlur) onBlur(event);
+  };
+
+  // Handle dropdown expanded state
+  const handleDropdownOpen = () => setExpanded(true);
+  const handleDropdownClose = () => setExpanded(false);
+
+  return (
+    <ThemeProvider theme={theme}>
+      <FormControl sx={{ m: 1, minWidth: 220, maxWidth: 220 }}>
+        <InputLabel
+          id="terminal-font-size-label"
+          sx={{
+            '&.Mui-focused': {
+              color: isFocused ? (colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)') : 'initial',
+            },
+          }}
+        >
+          Terminal Font Size
+        </InputLabel>
+        <Select
+          labelId="terminal-font-size-label"
+          id="terminal-font-size-select"
+          value={fontSize}
+          label="Terminal Font Size"
+          onChange={handleChange}
+          onFocus={handleFocus}
+          onBlur={handleBlur}
+          onOpen={handleDropdownOpen}
+          onClose={handleDropdownClose}
+          aria-expanded={expanded}
+          sx={{
+            '& .MuiSelect-select': {
+              color: isFocused || expanded ? (colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)') : 'initial',
+            },
+          }}
+        >
+          <MenuItem value="12">Small</MenuItem>
+          <MenuItem value="16">Medium</MenuItem>
+          <MenuItem value="18">Large</MenuItem>
+          <MenuItem value="24">Extra Large</MenuItem>
+        </Select>
+      </FormControl>
+    </ThemeProvider>
+  );
+};
+
+export default TerminalFontSizeDropdown;
diff --git a/src/components/xpath/XPathQueryInput/index.tsx b/src/components/xpath/XPathQueryInput/index.tsx
new file mode 100644
index 0000000000000..a66ec3b7f962f
--- /dev/null
+++ b/src/components/xpath/XPathQueryInput/index.tsx
@@ -0,0 +1,69 @@
+import React, { useState, FocusEvent, ChangeEvent } from 'react';
+import TextField from '@mui/material/TextField';
+import { useColorMode } from '@docusaurus/theme-common';
+import { createTheme, ThemeProvider } from '@mui/material/styles';
+
+// Define props interface
+interface XPathQueryInputProps {
+  value: string;
+  onChange: (event: ChangeEvent<HTMLInputElement>) => void;
+  onFocus?: (event: FocusEvent<HTMLInputElement>) => void;
+  onBlur?: (event: FocusEvent<HTMLInputElement>) => void;
+}
+
+const XPathQueryInput: React.FC<XPathQueryInputProps> = ({ value, onChange, onFocus, onBlur }) => {
+  const { colorMode } = useColorMode();
+  const [isFocused, setIsFocused] = useState<boolean>(false);
+
+  const theme = createTheme({
+    components: {
+      MuiOutlinedInput: {
+        styleOverrides: {
+          root: {
+            '& .MuiOutlinedInput-notchedOutline': {
+              borderColor: colorMode === 'dark' ? '#ffffff' : 'initial',
+              borderWidth: 1,
+            },
+            '&:hover .MuiOutlinedInput-notchedOutline': {
+              borderColor: colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)',
+            },
+          },
+        },
+      },
+    },
+  });
+
+  return (
+    <ThemeProvider theme={theme}>
+      <TextField
+        onFocus={(event) => {
+          setIsFocused(true);
+          if (onFocus) onFocus(event);
+        }}
+        onBlur={(event) => {
+          setIsFocused(false);
+          if (onBlur) onBlur(event);
+        }}
+        sx={{
+          m: 1,
+          minWidth: 800,
+          '& .MuiInputLabel-root': {
+            color: isFocused ? (colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)') : 'initial',
+          },
+          '& .MuiOutlinedInput-root.Mui-focused': {
+            '& fieldset': {
+              borderColor: colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)',
+            },
+          },
+        }}
+        id="outlined-basic-xpath-input"
+        label="Enter XPath query"
+        variant="outlined"
+        value={value}
+        onChange={onChange}
+      />
+    </ThemeProvider>
+  );
+};
+
+export default XPathQueryInput;
diff --git a/src/components/xpath/XPathRootInput/index.tsx b/src/components/xpath/XPathRootInput/index.tsx
new file mode 100644
index 0000000000000..3b8c6bdd46cee
--- /dev/null
+++ b/src/components/xpath/XPathRootInput/index.tsx
@@ -0,0 +1,69 @@
+import React, { useState, FocusEvent, ChangeEvent } from 'react';
+import TextField from '@mui/material/TextField';
+import { useColorMode } from '@docusaurus/theme-common';
+import { createTheme, ThemeProvider } from '@mui/material/styles';
+
+// Define props interface
+interface XPathRootInputProps {
+  value: string;
+  onChange: (event: ChangeEvent<HTMLInputElement>) => void;
+  onFocus?: (event: FocusEvent<HTMLInputElement>) => void;
+  onBlur?: (event: FocusEvent<HTMLInputElement>) => void;
+}
+
+const XPathRootInput: React.FC<XPathRootInputProps> = ({ value, onChange, onFocus, onBlur }) => {
+  const { colorMode } = useColorMode();
+  const [isFocused, setIsFocused] = useState<boolean>(false);
+
+  const theme = createTheme({
+    components: {
+      MuiOutlinedInput: {
+        styleOverrides: {
+          root: {
+            '& .MuiOutlinedInput-notchedOutline': {
+              borderColor: colorMode === 'dark' ? '#ffffff' : 'initial',
+              borderWidth: 1,
+            },
+            '&:hover .MuiOutlinedInput-notchedOutline': {
+              borderColor: colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)',
+            },
+          },
+        },
+      },
+    },
+  });
+
+  return (
+    <ThemeProvider theme={theme}>
+      <TextField
+        onFocus={(event) => {
+          setIsFocused(true);
+          if (onFocus) onFocus(event);
+        }}
+        onBlur={(event) => {
+          setIsFocused(false);
+          if (onBlur) onBlur(event);
+        }}
+        sx={{
+          m: 1,
+          minWidth: 800,
+          '& .MuiInputLabel-root': {
+            color: isFocused ? (colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)') : 'initial',
+          },
+          '& .MuiOutlinedInput-root.Mui-focused': {
+            '& fieldset': {
+              borderColor: colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)',
+            },
+          },
+        }}
+        id="outlined-basic-xpath-input"
+        label="Enter XPath root"
+        variant="outlined"
+        value={value}
+        onChange={onChange}
+      />
+    </ThemeProvider>
+  );
+};
+
+export default XPathRootInput;
diff --git a/src/components/xpath/useDebounce.ts b/src/components/xpath/useDebounce.ts
new file mode 100644
index 0000000000000..481ad379e122d
--- /dev/null
+++ b/src/components/xpath/useDebounce.ts
@@ -0,0 +1,16 @@
+import { useState, useEffect } from 'react';
+
+// Define the hook's return type
+export function useDebounce<T>(value: T, delay: number): T {
+  const [debouncedValue, setDebouncedValue] = useState<T>(value);
+
+  useEffect(() => {
+    const handler = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+
+    return () => clearTimeout(handler);
+  }, [value, delay]);
+
+  return debouncedValue;
+}
diff --git a/src/pages/tools/EscapeTool.module.css b/src/pages/tools/EscapeTool.module.css
index 7187a01c6cbf5..daa975baa60dd 100644
--- a/src/pages/tools/EscapeTool.module.css
+++ b/src/pages/tools/EscapeTool.module.css
@@ -31,12 +31,12 @@
   background: var(--terminal-background) !important;
 }
 
-a[id^='jsonpathDocumentationLink'] {
+a[id^='xpathDocumentationLink'] {
   color: var(--link-color) !important;
   text-decoration: underline !important;
 }
 
-a[id^='jsonpathDocumentationLink']:hover {
+a[id^='xpathDocumentationLink']:hover {
   text-decoration: none !important;
 }
 
@@ -51,15 +51,15 @@ div[id^='implementation-dropdown-select'] {
   color: var(--ifm-primary-text-color);
 }
 
-input[id^='outlined-basic-jsonpath-input'],
-label[id^='outlined-basic-jsonpath-input-label'],
+input[id^='outlined-basic-xpath-input'],
+label[id^='outlined-basic-xpath-input-label'],
 select[id^='terminal-font-size-select'],
 label[id^='terminal-font-size-label'],
 select[id^='implementation-dropdown-select'],
 label[id^='implementation-dropdown-label'] {
   color: var(--ifm-primary-text-color);
 }
-input[id^='outlined-basic-jsonpath-input'],
+input[id^='outlined-basic-xpath-input'],
 div[id^='terminal-font-size-select'],
 div[id^='implementation-dropdown-select'] {
   background: var(--terminal-background);
@@ -84,7 +84,7 @@ span[class^='ace_string'] {
   color: var(--terminal-value) !important;
 }
 
-div [id^='jsonpathalert'] {
+div [id^='xpathalert'] {
   color: rgb(244, 67, 54);
   border: 1px solid rgb(244, 67, 54);
 }
diff --git a/src/pages/tools/sample.xml.json b/src/pages/tools/sample.xml.json
new file mode 100644
index 0000000000000..53add47309662
--- /dev/null
+++ b/src/pages/tools/sample.xml.json
@@ -0,0 +1 @@
+{"xml":"<?xml version="1.0" encoding="UTF-8"?>
<env:Envelope
    xmlns:env="http://schemas.xmlsoap.org/soap/envelope/"
    xmlns:wd="urn:com.workday/bsvc">
  <env:Body>
    <wd:Get_Workers_Response wd:version="v43.0">

      <!-- ============================================================ -->
      <!-- RESPONSE FILTER / PAGINATION METADATA                        -->
      <!-- ============================================================ -->
      <wd:Request_References>
        <!-- Omitted when no filter was applied (i.e. all workers returned) -->
      </wd:Request_References>

      <wd:Response_Filter>
        <wd:As_Of_Effective_Date>2026-03-30</wd:As_Of_Effective_Date>
        <wd:As_Of_Entry_DateTime>2026-03-30T12:00:00.000-07:00</wd:As_Of_Entry_DateTime>
        <wd:Page>1</wd:Page>
        <wd:Count>100</wd:Count>
      </wd:Response_Filter>

      <wd:Response_Results>
        <wd:Total_Results>2</wd:Total_Results>
        <wd:Total_Pages>1</wd:Total_Pages>
        <wd:Page_Results>2</wd:Page_Results>
        <wd:Page>1</wd:Page>
      </wd:Response_Results>

      <wd:Response_Data>

        <!-- ============================================================ -->
        <!-- WORKER 1 — Active Employee                                   -->
        <!-- ============================================================ -->
        <wd:Worker>
          <wd:Worker_Reference>
            <wd:ID wd:type="WID">3aa5550b7fe348b5ae88c3af1b48c573</wd:ID>
            <wd:ID wd:type="Employee_ID">100234</wd:ID>
          </wd:Worker_Reference>

          <wd:Worker_Data>
            <wd:Worker_ID>100234</wd:Worker_ID>
            <wd:User_ID>jsmith</wd:User_ID>

            <!-- ======================================================== -->
            <!-- PERSONAL DATA                                             -->
            <!-- ======================================================== -->
            <wd:Personal_Data>

              <!-- === Name Data === -->
              <wd:Name_Data>
                <wd:Legal_Name_Data>
                  <wd:Name_Detail_Data>
                    <wd:Country_Reference>
                      <wd:ID wd:type="WID">bc33aa3152ec42d4995f4791a106ed09</wd:ID>
                      <wd:ID wd:type="ISO_3166-1_Alpha-2_Code">US</wd:ID>
                      <wd:ID wd:type="ISO_3166-1_Alpha-3_Code">USA</wd:ID>
                    </wd:Country_Reference>
                    <wd:First_Name>Jane</wd:First_Name>
                    <wd:Middle_Name>Marie</wd:Middle_Name>
                    <wd:Last_Name>Smith</wd:Last_Name>
                    <wd:Formatted_Name>Jane Marie Smith</wd:Formatted_Name>
                    <wd:Reporting_Name>Smith, Jane Marie</wd:Reporting_Name>
                  </wd:Name_Detail_Data>
                </wd:Legal_Name_Data>
                <wd:Preferred_Name_Data>
                  <wd:Name_Detail_Data>
                    <wd:Country_Reference>
                      <wd:ID wd:type="WID">bc33aa3152ec42d4995f4791a106ed09</wd:ID>
                      <wd:ID wd:type="ISO_3166-1_Alpha-2_Code">US</wd:ID>
                    </wd:Country_Reference>
                    <wd:First_Name>Jane</wd:First_Name>
                    <wd:Last_Name>Smith</wd:Last_Name>
                    <wd:Formatted_Name>Jane Smith</wd:Formatted_Name>
                    <wd:Reporting_Name>Smith, Jane</wd:Reporting_Name>
                  </wd:Name_Detail_Data>
                </wd:Preferred_Name_Data>
              </wd:Name_Data>

              <!-- === Contact Data === -->
              <wd:Contact_Data>

                <!-- Work Email -->
                <wd:Email_Address_Data>
                  <wd:Email_Address>jane.smith@acmecorp.com</wd:Email_Address>
                  <wd:Usage_Data wd:Public="true">
                    <wd:Type_Data wd:Primary="true">
                      <wd:Type_Reference>
                        <wd:ID wd:type="WID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</wd:ID>
                        <wd:ID wd:type="Communication_Usage_Type_ID">WORK</wd:ID>
                      </wd:Type_Reference>
                    </wd:Type_Data>
                  </wd:Usage_Data>
                </wd:Email_Address_Data>

                <!-- Home Email -->
                <wd:Email_Address_Data>
                  <wd:Email_Address>jane.m.smith@gmail.com</wd:Email_Address>
                  <wd:Usage_Data wd:Public="false">
                    <wd:Type_Data wd:Primary="false">
                      <wd:Type_Reference>
                        <wd:ID wd:type="WID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</wd:ID>
                        <wd:ID wd:type="Communication_Usage_Type_ID">HOME</wd:ID>
                      </wd:Type_Reference>
                    </wd:Type_Data>
                  </wd:Usage_Data>
                </wd:Email_Address_Data>

                <!-- Work Phone -->
                <wd:Phone_Data>
                  <wd:International_Phone_Code>1</wd:International_Phone_Code>
                  <wd:Area_Code>619</wd:Area_Code>
                  <wd:Phone_Number>555-0142</wd:Phone_Number>
                  <wd:Phone_Device_Type_Reference>
                    <wd:ID wd:type="WID">e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9</wd:ID>
                    <wd:ID wd:type="Phone_Device_Type_ID">Landline</wd:ID>
                  </wd:Phone_Device_Type_Reference>
                  <wd:Usage_Data wd:Public="true">
                    <wd:Type_Data wd:Primary="true">
                      <wd:Type_Reference>
                        <wd:ID wd:type="WID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</wd:ID>
                        <wd:ID wd:type="Communication_Usage_Type_ID">WORK</wd:ID>
                      </wd:Type_Reference>
                    </wd:Type_Data>
                  </wd:Usage_Data>
                  <wd:Formatted_Phone>+1 (619) 555-0142</wd:Formatted_Phone>
                </wd:Phone_Data>

                <!-- Mobile Phone -->
                <wd:Phone_Data>
                  <wd:International_Phone_Code>1</wd:International_Phone_Code>
                  <wd:Area_Code>858</wd:Area_Code>
                  <wd:Phone_Number>555-0198</wd:Phone_Number>
                  <wd:Phone_Device_Type_Reference>
                    <wd:ID wd:type="WID">f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0</wd:ID>
                    <wd:ID wd:type="Phone_Device_Type_ID">Mobile</wd:ID>
                  </wd:Phone_Device_Type_Reference>
                  <wd:Usage_Data wd:Public="false">
                    <wd:Type_Data wd:Primary="false">
                      <wd:Type_Reference>
                        <wd:ID wd:type="WID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</wd:ID>
                        <wd:ID wd:type="Communication_Usage_Type_ID">HOME</wd:ID>
                      </wd:Type_Reference>
                    </wd:Type_Data>
                  </wd:Usage_Data>
                  <wd:Formatted_Phone>+1 (858) 555-0198</wd:Formatted_Phone>
                </wd:Phone_Data>

                <!-- Home Address -->
                <wd:Address_Data>
                  <wd:Country_Reference>
                    <wd:ID wd:type="WID">bc33aa3152ec42d4995f4791a106ed09</wd:ID>
                    <wd:ID wd:type="ISO_3166-1_Alpha-2_Code">US</wd:ID>
                  </wd:Country_Reference>
                  <wd:Last_Modified>2024-06-15T09:30:00.000-07:00</wd:Last_Modified>
                  <wd:Address_Line_Data wd:Type="ADDRESS_LINE_1">742 Evergreen Terrace</wd:Address_Line_Data>
                  <wd:Address_Line_Data wd:Type="ADDRESS_LINE_2">Apt 4B</wd:Address_Line_Data>
                  <wd:Municipality>San Diego</wd:Municipality>
                  <wd:Country_Region_Reference>
                    <wd:ID wd:type="WID">a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3</wd:ID>
                    <wd:ID wd:type="Country_Region_ID">USA-CA</wd:ID>
                  </wd:Country_Region_Reference>
                  <wd:Country_Region_Descriptor>California</wd:Country_Region_Descriptor>
                  <wd:Postal_Code>92101</wd:Postal_Code>
                  <wd:Formatted_Address>742 Evergreen Terrace, Apt 4B, San Diego, CA 92101, United States of America</wd:Formatted_Address>
                  <wd:Defaulted_Business_Site_Address>false</wd:Defaulted_Business_Site_Address>
                  <wd:Number_of_Days>365</wd:Number_of_Days>
                  <wd:Usage_Data wd:Public="false">
                    <wd:Type_Data wd:Primary="true">
                      <wd:Type_Reference>
                        <wd:ID wd:type="WID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</wd:ID>
                        <wd:ID wd:type="Communication_Usage_Type_ID">HOME</wd:ID>
                      </wd:Type_Reference>
                    </wd:Type_Data>
                  </wd:Usage_Data>
                </wd:Address_Data>

              </wd:Contact_Data>

              <!-- === Biographical Data (date of birth, gender, etc.) === -->
              <wd:Biographical_Data>
                <wd:Date_of_Birth>1988-07-22</wd:Date_of_Birth>
                <wd:Gender_Reference>
                  <wd:ID wd:type="WID">9a0b1c2d3e4f5a6b7c8d9e0f1a2b3c4d</wd:ID>
                  <wd:ID wd:type="Gender_ID">Female</wd:ID>
                </wd:Gender_Reference>
                <wd:Country_of_Birth_Reference>
                  <wd:ID wd:type="WID">bc33aa3152ec42d4995f4791a106ed09</wd:ID>
                  <wd:ID wd:type="ISO_3166-1_Alpha-2_Code">US</wd:ID>
                </wd:Country_of_Birth_Reference>
                <wd:Marital_Status_Reference>
                  <wd:ID wd:type="WID">c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9</wd:ID>
                  <wd:ID wd:type="Marital_Status_ID">Married</wd:ID>
                </wd:Marital_Status_Reference>
                <wd:Marital_Status_Date>2019-10-05</wd:Marital_Status_Date>
              </wd:Biographical_Data>

              <!-- === ID Data (national IDs, government IDs) === -->
              <wd:Identification_Data>
                <wd:National_ID>
                  <wd:National_ID_Data>
                    <wd:ID>***-**-6789</wd:ID>
                    <wd:ID_Type_Reference>
                      <wd:ID wd:type="WID">e8f9a0b1c2d3e4f5a6b7c8d9e0f1a2b3</wd:ID>
                      <wd:ID wd:type="National_ID_Type_Code">USA-SSN</wd:ID>
                    </wd:ID_Type_Reference>
                    <wd:Country_Reference>
                      <wd:ID wd:type="WID">bc33aa3152ec42d4995f4791a106ed09</wd:ID>
                      <wd:ID wd:type="ISO_3166-1_Alpha-2_Code">US</wd:ID>
                    </wd:Country_Reference>
                    <wd:Issued_Date>2006-03-15</wd:Issued_Date>
                  </wd:National_ID_Data>
                </wd:National_ID>
                <wd:Custom_ID>
                  <wd:Custom_ID_Data>
                    <wd:ID>BADGE-00234</wd:ID>
                    <wd:ID_Type_Reference>
                      <wd:ID wd:type="WID">f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6</wd:ID>
                      <wd:ID wd:type="Custom_ID_Type_ID">Badge_ID</wd:ID>
                    </wd:ID_Type_Reference>
                  </wd:Custom_ID_Data>
                </wd:Custom_ID>
              </wd:Identification_Data>

            </wd:Personal_Data>

            <!-- ======================================================== -->
            <!-- EMPLOYMENT DATA                                           -->
            <!-- ======================================================== -->
            <wd:Employment_Data>

              <wd:Worker_Job_Data>
                <wd:Position_Data>
                  <wd:Position_ID>P-004521</wd:Position_ID>
                  <wd:Position_Title>Senior Software Engineer</wd:Position_Title>
                  <wd:Business_Title>Senior Software Engineer</wd:Business_Title>
                  <wd:Start_Date>2023-01-09</wd:Start_Date>
                  <wd:Default_Weekly_Hours>40</wd:Default_Weekly_Hours>
                  <wd:Scheduled_Weekly_Hours>40</wd:Scheduled_Weekly_Hours>
                  <wd:Full_Time_Equivalent_Percentage>100</wd:Full_Time_Equivalent_Percentage>

                  <wd:Position_Reference>
                    <wd:ID wd:type="WID">7bc6640c8af459c6bf99d4b02c59d001</wd:ID>
                    <wd:ID wd:type="Position_ID">P-004521</wd:ID>
                  </wd:Position_Reference>

                  <wd:Worker_Type_Reference>
                    <wd:ID wd:type="WID">d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9</wd:ID>
                    <wd:ID wd:type="Worker_Type_ID">Regular</wd:ID>
                  </wd:Worker_Type_Reference>

                  <wd:Job_Profile_Summary_Data>
                    <wd:Job_Profile_Reference>
                      <wd:ID wd:type="WID">1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d</wd:ID>
                      <wd:ID wd:type="Job_Profile_ID">JP-SWE-SR</wd:ID>
                    </wd:Job_Profile_Reference>
                    <wd:Job_Profile_Name>Senior Software Engineer</wd:Job_Profile_Name>
                    <wd:Management_Level_Reference>
                      <wd:ID wd:type="WID">2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e</wd:ID>
                      <wd:ID wd:type="Management_Level_ID">Individual_Contributor</wd:ID>
                    </wd:Management_Level_Reference>
                    <wd:Job_Category_Reference>
                      <wd:ID wd:type="WID">3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f</wd:ID>
                      <wd:ID wd:type="Job_Category_ID">Engineering</wd:ID>
                    </wd:Job_Category_Reference>
                    <wd:Job_Family_Reference>
                      <wd:ID wd:type="WID">4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a</wd:ID>
                      <wd:ID wd:type="Job_Family_ID">JF-Engineering</wd:ID>
                    </wd:Job_Family_Reference>
                  </wd:Job_Profile_Summary_Data>

                  <wd:Business_Site_Summary_Data>
                    <wd:Name>San Diego HQ</wd:Name>
                    <wd:Location_Reference>
                      <wd:ID wd:type="WID">5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b</wd:ID>
                      <wd:ID wd:type="Location_ID">LOC-SD-HQ</wd:ID>
                    </wd:Location_Reference>
                    <wd:Location_Type_Reference>
                      <wd:ID wd:type="WID">6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c</wd:ID>
                      <wd:ID wd:type="Location_Type_ID">Office</wd:ID>
                    </wd:Location_Type_Reference>
                    <wd:Address_Data>
                      <wd:Country_Reference>
                        <wd:ID wd:type="ISO_3166-1_Alpha-2_Code">US</wd:ID>
                      </wd:Country_Reference>
                      <wd:Address_Line_Data wd:Type="ADDRESS_LINE_1">100 Innovation Drive</wd:Address_Line_Data>
                      <wd:Address_Line_Data wd:Type="ADDRESS_LINE_2">Suite 500</wd:Address_Line_Data>
                      <wd:Municipality>San Diego</wd:Municipality>
                      <wd:Country_Region_Reference>
                        <wd:ID wd:type="Country_Region_ID">USA-CA</wd:ID>
                      </wd:Country_Region_Reference>
                      <wd:Country_Region_Descriptor>California</wd:Country_Region_Descriptor>
                      <wd:Postal_Code>92130</wd:Postal_Code>
                    </wd:Address_Data>
                  </wd:Business_Site_Summary_Data>

                  <!-- Pay Rate Type -->
                  <wd:Pay_Rate_Type_Reference>
                    <wd:ID wd:type="WID">7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d</wd:ID>
                    <wd:ID wd:type="Pay_Rate_Type_ID">Salary</wd:ID>
                  </wd:Pay_Rate_Type_Reference>

                  <!-- Time Type (Full_time / Part_time) -->
                  <wd:Position_Time_Type_Reference>
                    <wd:ID wd:type="WID">8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e</wd:ID>
                    <wd:ID wd:type="Position_Time_Type_ID">Full_time</wd:ID>
                  </wd:Position_Time_Type_Reference>

                  <!-- Supervisory Organization -->
                  <wd:Supervisory_Organization_Reference>
                    <wd:ID wd:type="WID">9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f</wd:ID>
                    <wd:ID wd:type="Organization_Reference_ID">ENG-PLATFORM-001</wd:ID>
                  </wd:Supervisory_Organization_Reference>

                  <!-- Cost Center -->
                  <wd:Organization_Data>
                    <wd:Worker_Organization_Data>
                      <wd:Organization_Data>
                        <wd:Organization_Reference>
                          <wd:ID wd:type="WID">0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a</wd:ID>
                          <wd:ID wd:type="Organization_Reference_ID">CC-4500</wd:ID>
                          <wd:ID wd:type="Cost_Center_Reference_ID">CC-4500</wd:ID>
                        </wd:Organization_Reference>
                        <wd:Organization_Name>Engineering - Platform</wd:Organization_Name>
                        <wd:Organization_Type_Reference>
                          <wd:ID wd:type="WID">1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b</wd:ID>
                          <wd:ID wd:type="Organization_Type_ID">Cost_Center</wd:ID>
                        </wd:Organization_Type_Reference>
                      </wd:Organization_Data>
                      <wd:Organization_Data>
                        <wd:Organization_Reference>
                          <wd:ID wd:type="WID">2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c</wd:ID>
                          <wd:ID wd:type="Organization_Reference_ID">COMP-ACME</wd:ID>
                          <wd:ID wd:type="Company_Reference_ID">COMP-ACME</wd:ID>
                        </wd:Organization_Reference>
                        <wd:Organization_Name>Acme Corporation</wd:Organization_Name>
                        <wd:Organization_Type_Reference>
                          <wd:ID wd:type="WID">3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d</wd:ID>
                          <wd:ID wd:type="Organization_Type_ID">Company</wd:ID>
                        </wd:Organization_Type_Reference>
                      </wd:Organization_Data>
                    </wd:Worker_Organization_Data>
                  </wd:Organization_Data>

                </wd:Position_Data>

                <!-- Manager Reference -->
                <wd:Manager_as_of_last_detected_manager_change_Reference>
                  <wd:ID wd:type="WID">aabbccdd11223344556677889900aabb</wd:ID>
                  <wd:ID wd:type="Employee_ID">100089</wd:ID>
                </wd:Manager_as_of_last_detected_manager_change_Reference>

                <!-- Worker Status (Active, Hire Date, etc.) -->
                <wd:Worker_Status_Data>
                  <wd:Active>true</wd:Active>
                  <wd:Active_Status_Date>2021-03-15</wd:Active_Status_Date>
                  <wd:Hire_Date>2021-03-15</wd:Hire_Date>
                  <wd:Original_Hire_Date>2021-03-15</wd:Original_Hire_Date>
                  <wd:End_Employment_Date/>
                  <wd:Continuous_Service_Date>2021-03-15</wd:Continuous_Service_Date>
                  <wd:First_Day_of_Work>2021-03-15</wd:First_Day_of_Work>
                  <wd:Seniority_Date>2021-03-15</wd:Seniority_Date>
                  <wd:Benefits_Service_Date>2021-03-15</wd:Benefits_Service_Date>
                  <wd:Company_Service_Date>2021-03-15</wd:Company_Service_Date>
                  <wd:Retired>false</wd:Retired>
                  <wd:Terminated>false</wd:Terminated>
                  <wd:Rehire>false</wd:Rehire>
                  <wd:Days_Unemployed>0</wd:Days_Unemployed>
                  <wd:Not_Returning>false</wd:Not_Returning>
                  <wd:Probation_Start_Date>2021-03-15</wd:Probation_Start_Date>
                  <wd:Probation_End_Date>2021-09-15</wd:Probation_End_Date>
                </wd:Worker_Status_Data>

              </wd:Worker_Job_Data>

              <!-- International Assignment (empty for this worker) -->
              <wd:Worker_Job_Data>
                <!-- Additional positions would appear as additional Worker_Job_Data elements -->
                <!-- This worker has only one position, so only one appears above -->
              </wd:Worker_Job_Data>

            </wd:Employment_Data>

          </wd:Worker_Data>
        </wd:Worker>

        <!-- ============================================================ -->
        <!-- WORKER 2 — Terminated Employee (tests your parser edge case) -->
        <!-- ============================================================ -->
        <wd:Worker>
          <wd:Worker_Reference>
            <wd:ID wd:type="WID">8dd7761e9bf54ac7b011e5c23d70fa92</wd:ID>
            <wd:ID wd:type="Employee_ID">100578</wd:ID>
          </wd:Worker_Reference>

          <wd:Worker_Data>
            <wd:Worker_ID>100578</wd:Worker_ID>
            <wd:User_ID>rgarcia</wd:User_ID>

            <!-- ======================================================== -->
            <!-- PERSONAL DATA                                             -->
            <!-- ======================================================== -->
            <wd:Personal_Data>

              <wd:Name_Data>
                <wd:Legal_Name_Data>
                  <wd:Name_Detail_Data>
                    <wd:Country_Reference>
                      <wd:ID wd:type="WID">bc33aa3152ec42d4995f4791a106ed09</wd:ID>
                      <wd:ID wd:type="ISO_3166-1_Alpha-2_Code">US</wd:ID>
                      <wd:ID wd:type="ISO_3166-1_Alpha-3_Code">USA</wd:ID>
                    </wd:Country_Reference>
                    <wd:First_Name>Roberto</wd:First_Name>
                    <wd:Last_Name>Garcia</wd:Last_Name>
                    <wd:Formatted_Name>Roberto Garcia</wd:Formatted_Name>
                    <wd:Reporting_Name>Garcia, Roberto</wd:Reporting_Name>
                  </wd:Name_Detail_Data>
                </wd:Legal_Name_Data>
                <wd:Preferred_Name_Data>
                  <wd:Name_Detail_Data>
                    <wd:Country_Reference>
                      <wd:ID wd:type="WID">bc33aa3152ec42d4995f4791a106ed09</wd:ID>
                      <wd:ID wd:type="ISO_3166-1_Alpha-2_Code">US</wd:ID>
                    </wd:Country_Reference>
                    <wd:First_Name>Rob</wd:First_Name>
                    <wd:Last_Name>Garcia</wd:Last_Name>
                    <wd:Formatted_Name>Rob Garcia</wd:Formatted_Name>
                    <wd:Reporting_Name>Garcia, Rob</wd:Reporting_Name>
                  </wd:Name_Detail_Data>
                </wd:Preferred_Name_Data>
              </wd:Name_Data>

              <wd:Contact_Data>

                <!-- Work Email -->
                <wd:Email_Address_Data>
                  <wd:Email_Address>roberto.garcia@acmecorp.com</wd:Email_Address>
                  <wd:Usage_Data wd:Public="true">
                    <wd:Type_Data wd:Primary="true">
                      <wd:Type_Reference>
                        <wd:ID wd:type="WID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</wd:ID>
                        <wd:ID wd:type="Communication_Usage_Type_ID">WORK</wd:ID>
                      </wd:Type_Reference>
                    </wd:Type_Data>
                  </wd:Usage_Data>
                </wd:Email_Address_Data>

                <!-- Work Phone -->
                <wd:Phone_Data>
                  <wd:International_Phone_Code>1</wd:International_Phone_Code>
                  <wd:Area_Code>512</wd:Area_Code>
                  <wd:Phone_Number>555-0377</wd:Phone_Number>
                  <wd:Phone_Device_Type_Reference>
                    <wd:ID wd:type="WID">e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9</wd:ID>
                    <wd:ID wd:type="Phone_Device_Type_ID">Landline</wd:ID>
                  </wd:Phone_Device_Type_Reference>
                  <wd:Usage_Data wd:Public="true">
                    <wd:Type_Data wd:Primary="true">
                      <wd:Type_Reference>
                        <wd:ID wd:type="WID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</wd:ID>
                        <wd:ID wd:type="Communication_Usage_Type_ID">WORK</wd:ID>
                      </wd:Type_Reference>
                    </wd:Type_Data>
                  </wd:Usage_Data>
                  <wd:Formatted_Phone>+1 (512) 555-0377</wd:Formatted_Phone>
                </wd:Phone_Data>

                <!-- Home Address -->
                <wd:Address_Data>
                  <wd:Country_Reference>
                    <wd:ID wd:type="WID">bc33aa3152ec42d4995f4791a106ed09</wd:ID>
                    <wd:ID wd:type="ISO_3166-1_Alpha-2_Code">US</wd:ID>
                  </wd:Country_Reference>
                  <wd:Last_Modified>2023-11-01T14:22:00.000-05:00</wd:Last_Modified>
                  <wd:Address_Line_Data wd:Type="ADDRESS_LINE_1">2200 Congress Avenue</wd:Address_Line_Data>
                  <wd:Municipality>Austin</wd:Municipality>
                  <wd:Country_Region_Reference>
                    <wd:ID wd:type="WID">b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e4</wd:ID>
                    <wd:ID wd:type="Country_Region_ID">USA-TX</wd:ID>
                  </wd:Country_Region_Reference>
                  <wd:Country_Region_Descriptor>Texas</wd:Country_Region_Descriptor>
                  <wd:Postal_Code>78701</wd:Postal_Code>
                  <wd:Formatted_Address>2200 Congress Avenue, Austin, TX 78701, United States of America</wd:Formatted_Address>
                  <wd:Defaulted_Business_Site_Address>false</wd:Defaulted_Business_Site_Address>
                  <wd:Usage_Data wd:Public="false">
                    <wd:Type_Data wd:Primary="true">
                      <wd:Type_Reference>
                        <wd:ID wd:type="WID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</wd:ID>
                        <wd:ID wd:type="Communication_Usage_Type_ID">HOME</wd:ID>
                      </wd:Type_Reference>
                    </wd:Type_Data>
                  </wd:Usage_Data>
                </wd:Address_Data>

              </wd:Contact_Data>

              <wd:Biographical_Data>
                <wd:Date_of_Birth>1992-11-03</wd:Date_of_Birth>
                <wd:Gender_Reference>
                  <wd:ID wd:type="WID">0a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d</wd:ID>
                  <wd:ID wd:type="Gender_ID">Male</wd:ID>
                </wd:Gender_Reference>
                <wd:Country_of_Birth_Reference>
                  <wd:ID wd:type="WID">bc33aa3152ec42d4995f4791a106ed09</wd:ID>
                  <wd:ID wd:type="ISO_3166-1_Alpha-2_Code">US</wd:ID>
                </wd:Country_of_Birth_Reference>
                <wd:Marital_Status_Reference>
                  <wd:ID wd:type="WID">d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0</wd:ID>
                  <wd:ID wd:type="Marital_Status_ID">Single</wd:ID>
                </wd:Marital_Status_Reference>
              </wd:Biographical_Data>

              <wd:Identification_Data>
                <wd:National_ID>
                  <wd:National_ID_Data>
                    <wd:ID>***-**-4321</wd:ID>
                    <wd:ID_Type_Reference>
                      <wd:ID wd:type="WID">e8f9a0b1c2d3e4f5a6b7c8d9e0f1a2b3</wd:ID>
                      <wd:ID wd:type="National_ID_Type_Code">USA-SSN</wd:ID>
                    </wd:ID_Type_Reference>
                    <wd:Country_Reference>
                      <wd:ID wd:type="WID">bc33aa3152ec42d4995f4791a106ed09</wd:ID>
                      <wd:ID wd:type="ISO_3166-1_Alpha-2_Code">US</wd:ID>
                    </wd:Country_Reference>
                  </wd:National_ID_Data>
                </wd:National_ID>
              </wd:Identification_Data>

            </wd:Personal_Data>

            <!-- ======================================================== -->
            <!-- EMPLOYMENT DATA                                           -->
            <!-- ======================================================== -->
            <wd:Employment_Data>

              <wd:Worker_Job_Data>
                <wd:Position_Data>
                  <wd:Position_ID>P-003887</wd:Position_ID>
                  <wd:Position_Title>Financial Analyst</wd:Position_Title>
                  <wd:Business_Title>Financial Analyst II</wd:Business_Title>
                  <wd:Start_Date>2022-06-01</wd:Start_Date>
                  <wd:End_Date>2025-12-20</wd:End_Date>
                  <wd:Default_Weekly_Hours>40</wd:Default_Weekly_Hours>
                  <wd:Scheduled_Weekly_Hours>40</wd:Scheduled_Weekly_Hours>
                  <wd:Full_Time_Equivalent_Percentage>100</wd:Full_Time_Equivalent_Percentage>

                  <wd:Position_Reference>
                    <wd:ID wd:type="WID">ccd8e9f0a1b2c3d4e5f6a7b8c9d0e1f2</wd:ID>
                    <wd:ID wd:type="Position_ID">P-003887</wd:ID>
                  </wd:Position_Reference>

                  <wd:Worker_Type_Reference>
                    <wd:ID wd:type="WID">d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9</wd:ID>
                    <wd:ID wd:type="Worker_Type_ID">Regular</wd:ID>
                  </wd:Worker_Type_Reference>

                  <wd:Job_Profile_Summary_Data>
                    <wd:Job_Profile_Reference>
                      <wd:ID wd:type="WID">aa11bb22cc33dd44ee55ff6600778899</wd:ID>
                      <wd:ID wd:type="Job_Profile_ID">JP-FIN-ANL</wd:ID>
                    </wd:Job_Profile_Reference>
                    <wd:Job_Profile_Name>Financial Analyst</wd:Job_Profile_Name>
                    <wd:Management_Level_Reference>
                      <wd:ID wd:type="WID">2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e</wd:ID>
                      <wd:ID wd:type="Management_Level_ID">Individual_Contributor</wd:ID>
                    </wd:Management_Level_Reference>
                    <wd:Job_Category_Reference>
                      <wd:ID wd:type="WID">bb22cc33dd44ee55ff66007788990011</wd:ID>
                      <wd:ID wd:type="Job_Category_ID">Finance</wd:ID>
                    </wd:Job_Category_Reference>
                    <wd:Job_Family_Reference>
                      <wd:ID wd:type="WID">cc33dd44ee55ff660077889900112233</wd:ID>
                      <wd:ID wd:type="Job_Family_ID">JF-Finance</wd:ID>
                    </wd:Job_Family_Reference>
                  </wd:Job_Profile_Summary_Data>

                  <wd:Business_Site_Summary_Data>
                    <wd:Name>Austin Office</wd:Name>
                    <wd:Location_Reference>
                      <wd:ID wd:type="WID">dd44ee55ff66007788990011223344aa</wd:ID>
                      <wd:ID wd:type="Location_ID">LOC-AUS-01</wd:ID>
                    </wd:Location_Reference>
                    <wd:Location_Type_Reference>
                      <wd:ID wd:type="WID">6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c</wd:ID>
                      <wd:ID wd:type="Location_Type_ID">Office</wd:ID>
                    </wd:Location_Type_Reference>
                    <wd:Address_Data>
                      <wd:Country_Reference>
                        <wd:ID wd:type="ISO_3166-1_Alpha-2_Code">US</wd:ID>
                      </wd:Country_Reference>
                      <wd:Address_Line_Data wd:Type="ADDRESS_LINE_1">500 West 2nd Street</wd:Address_Line_Data>
                      <wd:Address_Line_Data wd:Type="ADDRESS_LINE_2">Floor 12</wd:Address_Line_Data>
                      <wd:Municipality>Austin</wd:Municipality>
                      <wd:Country_Region_Reference>
                        <wd:ID wd:type="Country_Region_ID">USA-TX</wd:ID>
                      </wd:Country_Region_Reference>
                      <wd:Country_Region_Descriptor>Texas</wd:Country_Region_Descriptor>
                      <wd:Postal_Code>78701</wd:Postal_Code>
                    </wd:Address_Data>
                  </wd:Business_Site_Summary_Data>

                  <wd:Pay_Rate_Type_Reference>
                    <wd:ID wd:type="WID">7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d</wd:ID>
                    <wd:ID wd:type="Pay_Rate_Type_ID">Salary</wd:ID>
                  </wd:Pay_Rate_Type_Reference>

                  <wd:Position_Time_Type_Reference>
                    <wd:ID wd:type="WID">8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e</wd:ID>
                    <wd:ID wd:type="Position_Time_Type_ID">Full_time</wd:ID>
                  </wd:Position_Time_Type_Reference>

                  <wd:Supervisory_Organization_Reference>
                    <wd:ID wd:type="WID">ee55ff660077889900112233445566bb</wd:ID>
                    <wd:ID wd:type="Organization_Reference_ID">FIN-CORP-001</wd:ID>
                  </wd:Supervisory_Organization_Reference>

                  <wd:Organization_Data>
                    <wd:Worker_Organization_Data>
                      <wd:Organization_Data>
                        <wd:Organization_Reference>
                          <wd:ID wd:type="WID">ff660077889900112233445566778899</wd:ID>
                          <wd:ID wd:type="Organization_Reference_ID">CC-3200</wd:ID>
                          <wd:ID wd:type="Cost_Center_Reference_ID">CC-3200</wd:ID>
                        </wd:Organization_Reference>
                        <wd:Organization_Name>Finance - Corporate</wd:Organization_Name>
                        <wd:Organization_Type_Reference>
                          <wd:ID wd:type="WID">1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b</wd:ID>
                          <wd:ID wd:type="Organization_Type_ID">Cost_Center</wd:ID>
                        </wd:Organization_Type_Reference>
                      </wd:Organization_Data>
                      <wd:Organization_Data>
                        <wd:Organization_Reference>
                          <wd:ID wd:type="WID">2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c</wd:ID>
                          <wd:ID wd:type="Organization_Reference_ID">COMP-ACME</wd:ID>
                          <wd:ID wd:type="Company_Reference_ID">COMP-ACME</wd:ID>
                        </wd:Organization_Reference>
                        <wd:Organization_Name>Acme Corporation</wd:Organization_Name>
                        <wd:Organization_Type_Reference>
                          <wd:ID wd:type="WID">3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d</wd:ID>
                          <wd:ID wd:type="Organization_Type_ID">Company</wd:ID>
                        </wd:Organization_Type_Reference>
                      </wd:Organization_Data>
                    </wd:Worker_Organization_Data>
                  </wd:Organization_Data>

                </wd:Position_Data>

                <wd:Manager_as_of_last_detected_manager_change_Reference>
                  <wd:ID wd:type="WID">1122334455667788990011aabbccddee</wd:ID>
                  <wd:ID wd:type="Employee_ID">100102</wd:ID>
                </wd:Manager_as_of_last_detected_manager_change_Reference>

                <wd:Worker_Status_Data>
                  <wd:Active>false</wd:Active>
                  <wd:Active_Status_Date>2022-06-01</wd:Active_Status_Date>
                  <wd:Hire_Date>2022-06-01</wd:Hire_Date>
                  <wd:Original_Hire_Date>2022-06-01</wd:Original_Hire_Date>
                  <wd:End_Employment_Date>2025-12-20</wd:End_Employment_Date>
                  <wd:Continuous_Service_Date>2022-06-01</wd:Continuous_Service_Date>
                  <wd:First_Day_of_Work>2022-06-01</wd:First_Day_of_Work>
                  <wd:Seniority_Date>2022-06-01</wd:Seniority_Date>
                  <wd:Benefits_Service_Date>2022-06-01</wd:Benefits_Service_Date>
                  <wd:Company_Service_Date>2022-06-01</wd:Company_Service_Date>
                  <wd:Retired>false</wd:Retired>
                  <wd:Terminated>true</wd:Terminated>
                  <wd:Termination_Date>2025-12-20</wd:Termination_Date>
                  <wd:Pay_Through_Date>2025-12-31</wd:Pay_Through_Date>
                  <wd:Termination_Category_Reference>
                    <wd:ID wd:type="WID">aabb1122ccdd3344eeff5566aabb7788</wd:ID>
                    <wd:ID wd:type="Termination_Category_ID">Voluntary</wd:ID>
                  </wd:Termination_Category_Reference>
                  <wd:Primary_Termination_Reason_Reference>
                    <wd:ID wd:type="WID">ccdd3344eeff5566aabb778899001122</wd:ID>
                    <wd:ID wd:type="Termination_Reason_ID">Resignation - New Opportunity</wd:ID>
                  </wd:Primary_Termination_Reason_Reference>
                  <wd:Rehire>false</wd:Rehire>
                  <wd:Days_Unemployed>0</wd:Days_Unemployed>
                  <wd:Not_Returning>true</wd:Not_Returning>
                  <wd:Resignation_Date>2025-11-20</wd:Resignation_Date>
                  <wd:Last_Day_of_Work>2025-12-19</wd:Last_Day_of_Work>
                  <wd:Eligible_for_Rehire_Reference>
                    <wd:ID wd:type="WID">eeff5566aabb778899001122ccdd3344</wd:ID>
                    <wd:ID wd:type="Eligible_for_Rehire_ID">Yes</wd:ID>
                  </wd:Eligible_for_Rehire_Reference>
                </wd:Worker_Status_Data>

              </wd:Worker_Job_Data>

            </wd:Employment_Data>

          </wd:Worker_Data>
        </wd:Worker>

      </wd:Response_Data>
    </wd:Get_Workers_Response>
  </env:Body>
</env:Envelope>"}
\ No newline at end of file
diff --git a/src/pages/tools/xpath-evaluator.tsx b/src/pages/tools/xpath-evaluator.tsx
new file mode 100644
index 0000000000000..70de3b87f1dd4
--- /dev/null
+++ b/src/pages/tools/xpath-evaluator.tsx
@@ -0,0 +1,233 @@
+import React, {useState} from 'react';
+import Layout from '@theme/Layout';
+import styles from './xpath.module.css';
+import Alert from '@mui/material/Alert';
+import Stack from '@mui/material/Stack';
+import Link from '@mui/material/Link';
+import TerminalFontSizeDropdown from '../../components/xpath/TerminalFontSizeDropdown';
+import InputTerminal from '../../components/xpath/InputTerminal';
+import ResultTerminal from '../../components/xpath/ResultTerminal';
+import ImplementationDropdown from '../../components/xpath/ImplementationDropdown';
+import XPathQueryInput from '../../components/xpath/XPathQueryInput';
+import XPathRootInput from '../../components/xpath/XPathRootInput';
+import {
+  evaluateXPath,
+} from '../../services/XPathService';
+import useDocusaurusContext from '@docusaurus/useDocusaurusContext';
+import Button from '@mui/material/Button';
+
+// Define the type for implementation options
+type ImplementationType = 'XPath';
+
+// Define the documentation links type
+const documentationLinks: Record<
+  ImplementationType,
+  {url: string; text: string}
+> = {
+  XPath: {
+    url: 'https://en.wikipedia.org/wiki/XPath',
+    text: 'XPath Documentation',
+  },
+};
+  const sampleXmlFile = require('./sample.xml.json')
+  let buffer = new Buffer(sampleXmlFile.xml, 'base64');
+  const sampleXml = buffer.toString();
+  
+  const XPathEvaluator: React.FC = () => {
+  const [result, setResult] = useState<string>(JSON.stringify([], null, 4));
+  const [query, setQuery] = useState<string>('wd:Worker_Data/wd:Personal_Data/wd:Name_Data/wd:Legal_Name_Data/wd:Name_Detail_Data/wd:Last_Name | wd:Applicant_Data/wd:Personal_Data/wd:Name_Data/wd:Legal_Name_Data/wd:Name_Detail_Data/wd:Last_Name');
+  const [root, setRoot] = useState<string>('//wd:Response_Data/wd:Worker');
+  const [queryParseError, setQueryParseError] = useState<string>('');
+  const [fontSize, setFontSize] = useState<string>('16');
+  const [inputXml, setInputXml] = useState<string>(sampleXml);
+  const [implementation, setImplementation] =
+    useState<ImplementationType>('XPath');
+  const [localXml, setLocalXml] = useState<string>(inputXml);
+  const [xmlParseError, setXmlParseError] = useState<boolean>(false);
+  const [isQueryFocused, setIsQueryFocused] = useState<boolean>(false);
+  const [isRootFocused, setIsRootFocused] = useState<boolean>(false);
+  const [isDropdownFocused, setIsDropdownFocused] = useState<boolean>(false);
+  const {siteConfig} = useDocusaurusContext();
+
+  // Apply XPath query
+  const applyXPathQuery = async (xml: string, xPath: string, root: string) => {
+    if (xPath.length === 0 || xPath === '//') {
+      setResult('[]');
+      return;
+    }
+
+    try {
+      let result: any;
+      let tempResult: any;
+
+      try {
+        switch (implementation) {
+          case 'XPath':
+            tempResult = await evaluateXPath(
+              'https://o2352gowwy55a4vviyswr76lxu0ednjs.lambda-url.us-east-2.on.aws/',
+              xPath,
+			  root,
+              xml,
+            );
+            result = tempResult.error ? tempResult.error : tempResult;
+            break;
+        }
+      } catch (error: any) {
+        result = error.message;
+      }
+
+      setResult(
+        result.length > 0 ||
+          typeof result === 'number' ||
+          typeof result === 'object' ||
+          typeof result === 'boolean'
+          ? JSON.stringify(result, null, 2)
+          : 'No match',
+      );
+      setQueryParseError('');
+      setXmlParseError(false);
+    } catch (error: any) {
+      setResult('No match');
+      setXmlParseError(true);
+      setQueryParseError(error.message || 'Error executing XPath query');
+    }
+  };
+
+  // Handle input change
+  const handleXmlChange = (newxml: string) => {
+    setLocalXml(newxml);
+  };
+
+  // Handle query input change
+  const handleQueryChange = (event: React.ChangeEvent<HTMLInputElement>) => {
+    setQuery(event.target.value);
+  };
+
+  // Handle root input change
+  const handleRootChange = (event: React.ChangeEvent<HTMLInputElement>) => {
+    setRoot(event.target.value);
+  };
+
+  // Handle implementation change
+  const handleImplementationChange = (
+    newImplementation: ImplementationType,
+  ) => {
+    setImplementation(newImplementation);
+  };
+
+  // Handle focus events
+  const handleQueryFocus = () => setIsQueryFocused(true);
+  const handleQueryBlur = () => setIsQueryFocused(false);
+  const handleRootFocus = () => setIsRootFocused(true);
+  const handleRootBlur = () => setIsRootFocused(false);
+  const handleDropdownFocus = () => setIsDropdownFocused(true);
+  const handleDropdownBlur = () => setIsDropdownFocused(false);
+
+  // Run button handler
+  const handleRunQuery = () => {
+    applyXPathQuery(localXml, query, root);
+  };
+
+  return (
+    <Layout title="XPath Evaluator" description="The SailPoint Developer Community has everything you need to build, extend, and automate scalable identity solutions.">
+      <main>
+        <div className={styles.containerFluid}>
+          <div className={styles.actionBar}>
+            <Stack
+              sx={{justifyContent: 'center'}}
+              direction={{
+                xs: 'column',
+                sm: 'column',
+                md: 'column',
+                lg: 'column',
+                xl: 'row',
+              }}
+              spacing={1}>
+              <Stack sx={{justifyContent: 'center'}} spacing={1}>
+                <XPathRootInput
+                  value={root}
+                  onChange={handleRootChange}
+                  onFocus={handleRootFocus}
+                  onBlur={handleRootBlur}
+                />
+                {documentationLinks[implementation] && (
+                  <Link
+                    id="xpathDocumentationLink"
+                    href={documentationLinks[implementation].url}
+                    target="_blank"
+                    rel="noopener noreferrer">
+                    {documentationLinks[implementation].text}
+                  </Link>
+                )}
+              </Stack>
+              <Stack sx={{justifyContent: 'flex-start'}} spacing={1}>
+                <XPathQueryInput
+                  value={query}
+                  onChange={handleQueryChange}
+                  onFocus={handleQueryFocus}
+                  onBlur={handleQueryBlur}
+                />
+                {queryParseError && (
+                  <div className={styles.alertContainer}>
+                    <Alert id="xpathalert" severity="error">
+                      {queryParseError}
+                    </Alert>
+                  </div>
+                )}
+              </Stack>
+
+			  <Stack
+                sx={{justifyContent: 'flex-start'}}
+                direction={'row'}
+                spacing={1}>
+			  {(false && 
+				<ImplementationDropdown
+                  implementation={implementation}
+                  onImplementationChange={handleImplementationChange}
+                  onFocus={handleDropdownFocus}
+                  onBlur={handleDropdownBlur}
+				/>
+			  )}
+                <Button
+                  className={styles.runButton}
+                  variant="contained"
+                  onClick={handleRunQuery}
+                  sx={{height: '56px', minWidth: 220, maxWidth: 220}}>
+                  Run
+                </Button>
+
+                <TerminalFontSizeDropdown
+                  fontSize={fontSize}
+                  onFontSizeChange={setFontSize}
+                  onFocus={handleDropdownFocus}
+                  onBlur={handleDropdownBlur}
+                />
+              </Stack>
+            </Stack>
+          </div>
+
+          <Stack
+            sx={{justifyContent: 'center'}}
+            direction={{
+              xs: 'column',
+              sm: 'column',
+              md: 'column',
+              lg: 'row',
+              xl: 'row',
+            }}
+            spacing={1}>
+            <InputTerminal
+              fontSize={fontSize}
+              value={localXml}
+              onChange={handleXmlChange}
+              hasXmlParseError={xmlParseError}
+            />
+            <ResultTerminal result={result} fontSize={fontSize} />
+          </Stack>
+        </div>
+      </main>
+    </Layout>
+  );
+};
+
+export default XPathEvaluator;
diff --git a/src/pages/tools/xpath.module.css b/src/pages/tools/xpath.module.css
new file mode 100644
index 0000000000000..8d71f391778ca
--- /dev/null
+++ b/src/pages/tools/xpath.module.css
@@ -0,0 +1,96 @@
+.containerFluid {
+  margin: 20px;
+}
+
+.actionBar {
+  margin-top: 2%;
+  margin-bottom: 2%;
+}
+
+.alertContainer {
+  min-height: 50px;
+}
+
+.inputTerminalContainer {
+  border: 3px solid red !important;
+  background: var(--terminal-background) !important;
+}
+
+.terminalContainerDefault {
+  border: 3px solid var(--dev-card-background) !important;
+  background: var(--terminal-background) !important;
+}
+
+a[id^='xpathDocumentationLink'] {
+  color: var(--link-color) !important;
+  text-decoration: underline !important;
+}
+
+a[id^='xpathDocumentationLink']:hover {
+  text-decoration: none!important;
+}
+
+li[class^='MuiButtonBase-root'] {
+  color: var(--ifm-primary-text-color);
+}
+div[class^='MuiFormControl-root'] {
+  color: var(--ifm-primary-text-color);
+}
+div[id^='terminal-font-size-select'],
+div[id^='implementation-dropdown-select'] {
+  color: var(--ifm-primary-text-color);
+}
+
+input[id^='outlined-basic-xpath-input'],
+label[id^='outlined-basic-xpath-input-label'],
+select[id^='terminal-font-size-select'],
+label[id^='terminal-font-size-label'],
+select[id^='implementation-dropdown-select'],
+label[id^='implementation-dropdown-label'] {
+  color: var(--ifm-primary-text-color);
+}
+input[id^='outlined-basic-xpath-input'],
+div[id^='terminal-font-size-select'],
+div[id^='implementation-dropdown-select'] {
+  background: var(--terminal-background);
+}
+fieldset[class^='MuiOutlinedInput-notchedOutline css-1ll44ll-MuiOutlinedInput-notchedOutline'] {
+  border: 1.5px solid var(--terminal-background);
+}
+ul[class^='MuiList-root MuiList-padding MuiMenu-list css-1toxriw-MuiList-root-MuiMenu-list'] {
+  background-color: var(--terminal-background);
+}
+ul[class^='MuiMenu-list'] {
+  background-color: var(--terminal-background);
+}
+div[class^='MuiPaper-root'] {
+  background-color: var(--terminal-background) !important;
+}
+
+span[class^='ace_variable'] {
+  color: var(--terminal-key) !important;
+}
+span[class^='ace_string'] {
+  color: var(--terminal-value) !important;
+}
+
+div [id^='xpathalert'] {
+  color: rgb(244, 67, 54);
+  border: 1px solid rgb(244, 67, 54);
+}
+
+.actionBar button {
+  min-width: 100px;
+}
+
+.runButton {
+  color: var(--ifm-button-colors) !important;
+  border: 1px solid var(--ifm-button-colors) !important;
+  background-color: var(--dropdown-background) !important;
+}
+
+.runButton:hover {
+  background-color: var(--ifm-button-colors) !important;
+  color: var(--text-on-primary) !important;
+  border: 1px solid var(--ifm-button-colors) !important;
+}
diff --git a/src/services/XPathService.ts b/src/services/XPathService.ts
new file mode 100644
index 0000000000000..2b471841174af
--- /dev/null
+++ b/src/services/XPathService.ts
@@ -0,0 +1,58 @@
+// Common function to handle XPath evaluation
+export async function evaluateXPath(
+    gatewayUrl: string,
+    xPathQuery: string,
+    rootPath: string,
+    xmlData: string | object
+): Promise<any> {
+	const buffer = Buffer.from(xmlData);
+    const xmlb64String = buffer.toString('base64');
+
+    const requestBody = {
+        attributeMappings: {
+			'XPath Query Result': xPathQuery
+		},
+		rootPath: rootPath,
+        xml: xmlb64String
+    };
+
+    try {
+        const response = await fetch(`${gatewayUrl}`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(requestBody)
+        });
+
+        if (!response.ok) {
+            const errorResponse = await response.json();
+            console.error('JSONPath error:', errorResponse.error);
+
+            // Handle rate limiting specifically
+            if (response.status === 429) {
+                throw new Error('Too many requests. Please wait a moment and try again.');
+            }
+
+            throw new Error(`XPath evaluation error: ${errorResponse.error}`);
+        }
+
+        const json = await response.json();
+		console.log('Response JSON: ' + json);
+
+        // Parse the result if it's a string containing JSON
+        if (json.result && typeof json.result === 'string') {
+            try {
+                json.result = JSON.parse(json.result);
+            } catch (e) {
+                // If it's not valid JSON, keep the original string
+                console.log('Result was not JSON parseable, keeping as is');
+            }
+        }
+
+        return json;
+    } catch (error) {
+        console.error('Error evaluating XPath:', error);
+        throw error;
+    }
+}
\ No newline at end of file

From 893d86b14cd151f35f8f4fa6f513ee4a8b59143e Mon Sep 17 00:00:00 2001
From: ken-werner-sp <ken.werner@sailpoint.com>
Date: Wed, 1 Apr 2026 22:36:16 -0700
Subject: [PATCH 2/4] bugfixes

Terminal class updates based on error bool hasXmlParseError
Ace Editor module URL correction
---
 src/components/xpath/InputTerminal/index.tsx | 10 +++++-----
 src/pages/tools/xpath-evaluator.tsx          | 16 +++++++---------
 2 files changed, 12 insertions(+), 14 deletions(-)

diff --git a/src/components/xpath/InputTerminal/index.tsx b/src/components/xpath/InputTerminal/index.tsx
index 20906415062e2..5c464b1845cf3 100644
--- a/src/components/xpath/InputTerminal/index.tsx
+++ b/src/components/xpath/InputTerminal/index.tsx
@@ -12,7 +12,7 @@ import styles from '../../../pages/tools/xpath.module.css';
 declare const ace: any;
 if (typeof ace !== 'undefined' && ace.config) {
   ace.config.setModuleUrl(
-    'ace/mode/json_worker',
+    'ace/mode/xml_worker',
     new URL(
       'https://ajaxorg.github.io/ace-builds/src-noconflict/worker-xml.js'
     ).toString(),
@@ -23,7 +23,7 @@ interface InputTerminalProps {
   fontSize: string;
   value: string;
   onChange: (value: string) => void;
-  hasJsonParseError?: boolean;
+  hasXmlParseError?: boolean;
   mode?: 'xml' | 'text'; // 🔄 new optional mode prop
 }
 
@@ -31,12 +31,12 @@ const InputTerminal: React.FC<InputTerminalProps> = ({
   fontSize,
   value,
   onChange,
-  hasJsonParseError = false,
-  mode = 'xml', // default to 'json' for backward compatibility
+  hasXmlParseError = false,
+  mode = 'xml',
 }) => {
   const { colorMode } = useColorMode();
 
-  const terminalClass = hasJsonParseError
+  const terminalClass = hasXmlParseError
     ? styles.inputTerminalContainer
     : styles.terminalContainerDefault;
 
diff --git a/src/pages/tools/xpath-evaluator.tsx b/src/pages/tools/xpath-evaluator.tsx
index 70de3b87f1dd4..9a6e09698b7ce 100644
--- a/src/pages/tools/xpath-evaluator.tsx
+++ b/src/pages/tools/xpath-evaluator.tsx
@@ -30,7 +30,7 @@ const documentationLinks: Record<
   },
 };
   const sampleXmlFile = require('./sample.xml.json')
-  let buffer = new Buffer(sampleXmlFile.xml, 'base64');
+  let buffer = Buffer.from(sampleXmlFile.xml, 'base64')
   const sampleXml = buffer.toString();
   
   const XPathEvaluator: React.FC = () => {
@@ -150,6 +150,12 @@ const documentationLinks: Record<
                   onFocus={handleRootFocus}
                   onBlur={handleRootBlur}
                 />
+                <XPathQueryInput
+                  value={query}
+                  onChange={handleQueryChange}
+                  onFocus={handleQueryFocus}
+                  onBlur={handleQueryBlur}
+                />
                 {documentationLinks[implementation] && (
                   <Link
                     id="xpathDocumentationLink"
@@ -159,14 +165,6 @@ const documentationLinks: Record<
                     {documentationLinks[implementation].text}
                   </Link>
                 )}
-              </Stack>
-              <Stack sx={{justifyContent: 'flex-start'}} spacing={1}>
-                <XPathQueryInput
-                  value={query}
-                  onChange={handleQueryChange}
-                  onFocus={handleQueryFocus}
-                  onBlur={handleQueryBlur}
-                />
                 {queryParseError && (
                   <div className={styles.alertContainer}>
                     <Alert id="xpathalert" severity="error">

From 6fad506c61f9ea0f440228637ee3d8db156c5c30 Mon Sep 17 00:00:00 2001
From: ken-werner-sp <ken.werner@sailpoint.com>
Date: Wed, 1 Apr 2026 23:07:31 -0700
Subject: [PATCH 3/4] Add xpath lambda to cloudfront csp

---
 template.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/template.yaml b/template.yaml
index 0b470e74d6c35..29048fe351ea2 100644
--- a/template.yaml
+++ b/template.yaml
@@ -360,7 +360,7 @@ Resources:
         Comment: "Security headers for developer.sailpoint.com including CSP"
         SecurityHeadersConfig:
           ContentSecurityPolicy:
-            ContentSecurityPolicy: "default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval' https://code.jquery.com https://www.googletagmanager.com https://cdn.jsdelivr.net https://cdn.cookielaw.org https://googleads.g.doubleclick.net; style-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net https://p.typekit.net https://use.typekit.net; img-src 'self' data: https: http:; font-src 'self' data: https://cdn.jsdelivr.net https://use.typekit.net https://cdnjs.cloudflare.com; connect-src 'self' http://localhost:3000 https://*.algolia.net https://*.algolianet.com https://www.googletagmanager.com https://www.google.com https://analytics.google.com https://developer.sailpoint.com https://nug87yusrg.execute-api.us-east-1.amazonaws.com https://cdn.cookielaw.org https://stats.g.doubleclick.net https://googleads.g.doubleclick.net https://*.api.identitynow.com https://*.api.identitynow-demo.com; frame-src 'self' https://www.googletagmanager.com https://www.youtube.com https://play.vidyard.com; worker-src 'self' blob:;"
+            ContentSecurityPolicy: "default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval' https://code.jquery.com https://www.googletagmanager.com https://cdn.jsdelivr.net https://cdn.cookielaw.org https://googleads.g.doubleclick.net; style-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net https://p.typekit.net https://use.typekit.net; img-src 'self' data: https: http:; font-src 'self' data: https://cdn.jsdelivr.net https://use.typekit.net https://cdnjs.cloudflare.com; connect-src 'self' http://localhost:3000 https://*.algolia.net https://*.algolianet.com https://www.googletagmanager.com https://www.google.com https://analytics.google.com https://developer.sailpoint.com https://nug87yusrg.execute-api.us-east-1.amazonaws.com https://o2352gowwy55a4vviyswr76lxu0ednjs.lambda-url.us-east-2.on.aws https://cdn.cookielaw.org https://stats.g.doubleclick.net https://googleads.g.doubleclick.net https://*.api.identitynow.com https://*.api.identitynow-demo.com; frame-src 'self' https://www.googletagmanager.com https://www.youtube.com https://play.vidyard.com; worker-src 'self' blob:;"
             Override: true
 Parameters:
   AuthUsername:

From 8ebe24e534fbb57665d0f39c39b96a1e8d13c3ca Mon Sep 17 00:00:00 2001
From: ken-werner-sp <ken.werner@sailpoint.com>
Date: Wed, 1 Apr 2026 23:35:59 -0700
Subject: [PATCH 4/4] Update sample data

Remove fake "WorkDay" data, use fake data from nonexistent HR source "Xylophonic HR"
---
 src/pages/tools/sample.xml.json     | 2 +-
 src/pages/tools/xpath-evaluator.tsx | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/pages/tools/sample.xml.json b/src/pages/tools/sample.xml.json
index 53add47309662..c4935a5ff0468 100644
--- a/src/pages/tools/sample.xml.json
+++ b/src/pages/tools/sample.xml.json
@@ -1 +1 @@
-{"xml":"<?xml version="1.0" encoding="UTF-8"?>
<env:Envelope
    xmlns:env="http://schemas.xmlsoap.org/soap/envelope/"
    xmlns:wd="urn:com.workday/bsvc">
  <env:Body>
    <wd:Get_Workers_Response wd:version="v43.0">

      <!-- ============================================================ -->
      <!-- RESPONSE FILTER / PAGINATION METADATA                        -->
      <!-- ============================================================ -->
      <wd:Request_References>
        <!-- Omitted when no filter was applied (i.e. all workers returned) -->
      </wd:Request_References>

      <wd:Response_Filter>
        <wd:As_Of_Effective_Date>2026-03-30</wd:As_Of_Effective_Date>
        <wd:As_Of_Entry_DateTime>2026-03-30T12:00:00.000-07:00</wd:As_Of_Entry_DateTime>
        <wd:Page>1</wd:Page>
        <wd:Count>100</wd:Count>
      </wd:Response_Filter>

      <wd:Response_Results>
        <wd:Total_Results>2</wd:Total_Results>
        <wd:Total_Pages>1</wd:Total_Pages>
        <wd:Page_Results>2</wd:Page_Results>
        <wd:Page>1</wd:Page>
      </wd:Response_Results>

      <wd:Response_Data>

        <!-- ============================================================ -->
        <!-- WORKER 1 — Active Employee                                   -->
        <!-- ============================================================ -->
        <wd:Worker>
          <wd:Worker_Reference>
            <wd:ID wd:type="WID">3aa5550b7fe348b5ae88c3af1b48c573</wd:ID>
            <wd:ID wd:type="Employee_ID">100234</wd:ID>
          </wd:Worker_Reference>

          <wd:Worker_Data>
            <wd:Worker_ID>100234</wd:Worker_ID>
            <wd:User_ID>jsmith</wd:User_ID>

            <!-- ======================================================== -->
            <!-- PERSONAL DATA                                             -->
            <!-- ======================================================== -->
            <wd:Personal_Data>

              <!-- === Name Data === -->
              <wd:Name_Data>
                <wd:Legal_Name_Data>
                  <wd:Name_Detail_Data>
                    <wd:Country_Reference>
                      <wd:ID wd:type="WID">bc33aa3152ec42d4995f4791a106ed09</wd:ID>
                      <wd:ID wd:type="ISO_3166-1_Alpha-2_Code">US</wd:ID>
                      <wd:ID wd:type="ISO_3166-1_Alpha-3_Code">USA</wd:ID>
                    </wd:Country_Reference>
                    <wd:First_Name>Jane</wd:First_Name>
                    <wd:Middle_Name>Marie</wd:Middle_Name>
                    <wd:Last_Name>Smith</wd:Last_Name>
                    <wd:Formatted_Name>Jane Marie Smith</wd:Formatted_Name>
                    <wd:Reporting_Name>Smith, Jane Marie</wd:Reporting_Name>
                  </wd:Name_Detail_Data>
                </wd:Legal_Name_Data>
                <wd:Preferred_Name_Data>
                  <wd:Name_Detail_Data>
                    <wd:Country_Reference>
                      <wd:ID wd:type="WID">bc33aa3152ec42d4995f4791a106ed09</wd:ID>
                      <wd:ID wd:type="ISO_3166-1_Alpha-2_Code">US</wd:ID>
                    </wd:Country_Reference>
                    <wd:First_Name>Jane</wd:First_Name>
                    <wd:Last_Name>Smith</wd:Last_Name>
                    <wd:Formatted_Name>Jane Smith</wd:Formatted_Name>
                    <wd:Reporting_Name>Smith, Jane</wd:Reporting_Name>
                  </wd:Name_Detail_Data>
                </wd:Preferred_Name_Data>
              </wd:Name_Data>

              <!-- === Contact Data === -->
              <wd:Contact_Data>

                <!-- Work Email -->
                <wd:Email_Address_Data>
                  <wd:Email_Address>jane.smith@acmecorp.com</wd:Email_Address>
                  <wd:Usage_Data wd:Public="true">
                    <wd:Type_Data wd:Primary="true">
                      <wd:Type_Reference>
                        <wd:ID wd:type="WID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</wd:ID>
                        <wd:ID wd:type="Communication_Usage_Type_ID">WORK</wd:ID>
                      </wd:Type_Reference>
                    </wd:Type_Data>
                  </wd:Usage_Data>
                </wd:Email_Address_Data>

                <!-- Home Email -->
                <wd:Email_Address_Data>
                  <wd:Email_Address>jane.m.smith@gmail.com</wd:Email_Address>
                  <wd:Usage_Data wd:Public="false">
                    <wd:Type_Data wd:Primary="false">
                      <wd:Type_Reference>
                        <wd:ID wd:type="WID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</wd:ID>
                        <wd:ID wd:type="Communication_Usage_Type_ID">HOME</wd:ID>
                      </wd:Type_Reference>
                    </wd:Type_Data>
                  </wd:Usage_Data>
                </wd:Email_Address_Data>

                <!-- Work Phone -->
                <wd:Phone_Data>
                  <wd:International_Phone_Code>1</wd:International_Phone_Code>
                  <wd:Area_Code>619</wd:Area_Code>
                  <wd:Phone_Number>555-0142</wd:Phone_Number>
                  <wd:Phone_Device_Type_Reference>
                    <wd:ID wd:type="WID">e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9</wd:ID>
                    <wd:ID wd:type="Phone_Device_Type_ID">Landline</wd:ID>
                  </wd:Phone_Device_Type_Reference>
                  <wd:Usage_Data wd:Public="true">
                    <wd:Type_Data wd:Primary="true">
                      <wd:Type_Reference>
                        <wd:ID wd:type="WID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</wd:ID>
                        <wd:ID wd:type="Communication_Usage_Type_ID">WORK</wd:ID>
                      </wd:Type_Reference>
                    </wd:Type_Data>
                  </wd:Usage_Data>
                  <wd:Formatted_Phone>+1 (619) 555-0142</wd:Formatted_Phone>
                </wd:Phone_Data>

                <!-- Mobile Phone -->
                <wd:Phone_Data>
                  <wd:International_Phone_Code>1</wd:International_Phone_Code>
                  <wd:Area_Code>858</wd:Area_Code>
                  <wd:Phone_Number>555-0198</wd:Phone_Number>
                  <wd:Phone_Device_Type_Reference>
                    <wd:ID wd:type="WID">f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0</wd:ID>
                    <wd:ID wd:type="Phone_Device_Type_ID">Mobile</wd:ID>
                  </wd:Phone_Device_Type_Reference>
                  <wd:Usage_Data wd:Public="false">
                    <wd:Type_Data wd:Primary="false">
                      <wd:Type_Reference>
                        <wd:ID wd:type="WID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</wd:ID>
                        <wd:ID wd:type="Communication_Usage_Type_ID">HOME</wd:ID>
                      </wd:Type_Reference>
                    </wd:Type_Data>
                  </wd:Usage_Data>
                  <wd:Formatted_Phone>+1 (858) 555-0198</wd:Formatted_Phone>
                </wd:Phone_Data>

                <!-- Home Address -->
                <wd:Address_Data>
                  <wd:Country_Reference>
                    <wd:ID wd:type="WID">bc33aa3152ec42d4995f4791a106ed09</wd:ID>
                    <wd:ID wd:type="ISO_3166-1_Alpha-2_Code">US</wd:ID>
                  </wd:Country_Reference>
                  <wd:Last_Modified>2024-06-15T09:30:00.000-07:00</wd:Last_Modified>
                  <wd:Address_Line_Data wd:Type="ADDRESS_LINE_1">742 Evergreen Terrace</wd:Address_Line_Data>
                  <wd:Address_Line_Data wd:Type="ADDRESS_LINE_2">Apt 4B</wd:Address_Line_Data>
                  <wd:Municipality>San Diego</wd:Municipality>
                  <wd:Country_Region_Reference>
                    <wd:ID wd:type="WID">a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3</wd:ID>
                    <wd:ID wd:type="Country_Region_ID">USA-CA</wd:ID>
                  </wd:Country_Region_Reference>
                  <wd:Country_Region_Descriptor>California</wd:Country_Region_Descriptor>
                  <wd:Postal_Code>92101</wd:Postal_Code>
                  <wd:Formatted_Address>742 Evergreen Terrace, Apt 4B, San Diego, CA 92101, United States of America</wd:Formatted_Address>
                  <wd:Defaulted_Business_Site_Address>false</wd:Defaulted_Business_Site_Address>
                  <wd:Number_of_Days>365</wd:Number_of_Days>
                  <wd:Usage_Data wd:Public="false">
                    <wd:Type_Data wd:Primary="true">
                      <wd:Type_Reference>
                        <wd:ID wd:type="WID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</wd:ID>
                        <wd:ID wd:type="Communication_Usage_Type_ID">HOME</wd:ID>
                      </wd:Type_Reference>
                    </wd:Type_Data>
                  </wd:Usage_Data>
                </wd:Address_Data>

              </wd:Contact_Data>

              <!-- === Biographical Data (date of birth, gender, etc.) === -->
              <wd:Biographical_Data>
                <wd:Date_of_Birth>1988-07-22</wd:Date_of_Birth>
                <wd:Gender_Reference>
                  <wd:ID wd:type="WID">9a0b1c2d3e4f5a6b7c8d9e0f1a2b3c4d</wd:ID>
                  <wd:ID wd:type="Gender_ID">Female</wd:ID>
                </wd:Gender_Reference>
                <wd:Country_of_Birth_Reference>
                  <wd:ID wd:type="WID">bc33aa3152ec42d4995f4791a106ed09</wd:ID>
                  <wd:ID wd:type="ISO_3166-1_Alpha-2_Code">US</wd:ID>
                </wd:Country_of_Birth_Reference>
                <wd:Marital_Status_Reference>
                  <wd:ID wd:type="WID">c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9</wd:ID>
                  <wd:ID wd:type="Marital_Status_ID">Married</wd:ID>
                </wd:Marital_Status_Reference>
                <wd:Marital_Status_Date>2019-10-05</wd:Marital_Status_Date>
              </wd:Biographical_Data>

              <!-- === ID Data (national IDs, government IDs) === -->
              <wd:Identification_Data>
                <wd:National_ID>
                  <wd:National_ID_Data>
                    <wd:ID>***-**-6789</wd:ID>
                    <wd:ID_Type_Reference>
                      <wd:ID wd:type="WID">e8f9a0b1c2d3e4f5a6b7c8d9e0f1a2b3</wd:ID>
                      <wd:ID wd:type="National_ID_Type_Code">USA-SSN</wd:ID>
                    </wd:ID_Type_Reference>
                    <wd:Country_Reference>
                      <wd:ID wd:type="WID">bc33aa3152ec42d4995f4791a106ed09</wd:ID>
                      <wd:ID wd:type="ISO_3166-1_Alpha-2_Code">US</wd:ID>
                    </wd:Country_Reference>
                    <wd:Issued_Date>2006-03-15</wd:Issued_Date>
                  </wd:National_ID_Data>
                </wd:National_ID>
                <wd:Custom_ID>
                  <wd:Custom_ID_Data>
                    <wd:ID>BADGE-00234</wd:ID>
                    <wd:ID_Type_Reference>
                      <wd:ID wd:type="WID">f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6</wd:ID>
                      <wd:ID wd:type="Custom_ID_Type_ID">Badge_ID</wd:ID>
                    </wd:ID_Type_Reference>
                  </wd:Custom_ID_Data>
                </wd:Custom_ID>
              </wd:Identification_Data>

            </wd:Personal_Data>

            <!-- ======================================================== -->
            <!-- EMPLOYMENT DATA                                           -->
            <!-- ======================================================== -->
            <wd:Employment_Data>

              <wd:Worker_Job_Data>
                <wd:Position_Data>
                  <wd:Position_ID>P-004521</wd:Position_ID>
                  <wd:Position_Title>Senior Software Engineer</wd:Position_Title>
                  <wd:Business_Title>Senior Software Engineer</wd:Business_Title>
                  <wd:Start_Date>2023-01-09</wd:Start_Date>
                  <wd:Default_Weekly_Hours>40</wd:Default_Weekly_Hours>
                  <wd:Scheduled_Weekly_Hours>40</wd:Scheduled_Weekly_Hours>
                  <wd:Full_Time_Equivalent_Percentage>100</wd:Full_Time_Equivalent_Percentage>

                  <wd:Position_Reference>
                    <wd:ID wd:type="WID">7bc6640c8af459c6bf99d4b02c59d001</wd:ID>
                    <wd:ID wd:type="Position_ID">P-004521</wd:ID>
                  </wd:Position_Reference>

                  <wd:Worker_Type_Reference>
                    <wd:ID wd:type="WID">d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9</wd:ID>
                    <wd:ID wd:type="Worker_Type_ID">Regular</wd:ID>
                  </wd:Worker_Type_Reference>

                  <wd:Job_Profile_Summary_Data>
                    <wd:Job_Profile_Reference>
                      <wd:ID wd:type="WID">1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d</wd:ID>
                      <wd:ID wd:type="Job_Profile_ID">JP-SWE-SR</wd:ID>
                    </wd:Job_Profile_Reference>
                    <wd:Job_Profile_Name>Senior Software Engineer</wd:Job_Profile_Name>
                    <wd:Management_Level_Reference>
                      <wd:ID wd:type="WID">2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e</wd:ID>
                      <wd:ID wd:type="Management_Level_ID">Individual_Contributor</wd:ID>
                    </wd:Management_Level_Reference>
                    <wd:Job_Category_Reference>
                      <wd:ID wd:type="WID">3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f</wd:ID>
                      <wd:ID wd:type="Job_Category_ID">Engineering</wd:ID>
                    </wd:Job_Category_Reference>
                    <wd:Job_Family_Reference>
                      <wd:ID wd:type="WID">4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a</wd:ID>
                      <wd:ID wd:type="Job_Family_ID">JF-Engineering</wd:ID>
                    </wd:Job_Family_Reference>
                  </wd:Job_Profile_Summary_Data>

                  <wd:Business_Site_Summary_Data>
                    <wd:Name>San Diego HQ</wd:Name>
                    <wd:Location_Reference>
                      <wd:ID wd:type="WID">5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b</wd:ID>
                      <wd:ID wd:type="Location_ID">LOC-SD-HQ</wd:ID>
                    </wd:Location_Reference>
                    <wd:Location_Type_Reference>
                      <wd:ID wd:type="WID">6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c</wd:ID>
                      <wd:ID wd:type="Location_Type_ID">Office</wd:ID>
                    </wd:Location_Type_Reference>
                    <wd:Address_Data>
                      <wd:Country_Reference>
                        <wd:ID wd:type="ISO_3166-1_Alpha-2_Code">US</wd:ID>
                      </wd:Country_Reference>
                      <wd:Address_Line_Data wd:Type="ADDRESS_LINE_1">100 Innovation Drive</wd:Address_Line_Data>
                      <wd:Address_Line_Data wd:Type="ADDRESS_LINE_2">Suite 500</wd:Address_Line_Data>
                      <wd:Municipality>San Diego</wd:Municipality>
                      <wd:Country_Region_Reference>
                        <wd:ID wd:type="Country_Region_ID">USA-CA</wd:ID>
                      </wd:Country_Region_Reference>
                      <wd:Country_Region_Descriptor>California</wd:Country_Region_Descriptor>
                      <wd:Postal_Code>92130</wd:Postal_Code>
                    </wd:Address_Data>
                  </wd:Business_Site_Summary_Data>

                  <!-- Pay Rate Type -->
                  <wd:Pay_Rate_Type_Reference>
                    <wd:ID wd:type="WID">7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d</wd:ID>
                    <wd:ID wd:type="Pay_Rate_Type_ID">Salary</wd:ID>
                  </wd:Pay_Rate_Type_Reference>

                  <!-- Time Type (Full_time / Part_time) -->
                  <wd:Position_Time_Type_Reference>
                    <wd:ID wd:type="WID">8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e</wd:ID>
                    <wd:ID wd:type="Position_Time_Type_ID">Full_time</wd:ID>
                  </wd:Position_Time_Type_Reference>

                  <!-- Supervisory Organization -->
                  <wd:Supervisory_Organization_Reference>
                    <wd:ID wd:type="WID">9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f</wd:ID>
                    <wd:ID wd:type="Organization_Reference_ID">ENG-PLATFORM-001</wd:ID>
                  </wd:Supervisory_Organization_Reference>

                  <!-- Cost Center -->
                  <wd:Organization_Data>
                    <wd:Worker_Organization_Data>
                      <wd:Organization_Data>
                        <wd:Organization_Reference>
                          <wd:ID wd:type="WID">0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a</wd:ID>
                          <wd:ID wd:type="Organization_Reference_ID">CC-4500</wd:ID>
                          <wd:ID wd:type="Cost_Center_Reference_ID">CC-4500</wd:ID>
                        </wd:Organization_Reference>
                        <wd:Organization_Name>Engineering - Platform</wd:Organization_Name>
                        <wd:Organization_Type_Reference>
                          <wd:ID wd:type="WID">1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b</wd:ID>
                          <wd:ID wd:type="Organization_Type_ID">Cost_Center</wd:ID>
                        </wd:Organization_Type_Reference>
                      </wd:Organization_Data>
                      <wd:Organization_Data>
                        <wd:Organization_Reference>
                          <wd:ID wd:type="WID">2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c</wd:ID>
                          <wd:ID wd:type="Organization_Reference_ID">COMP-ACME</wd:ID>
                          <wd:ID wd:type="Company_Reference_ID">COMP-ACME</wd:ID>
                        </wd:Organization_Reference>
                        <wd:Organization_Name>Acme Corporation</wd:Organization_Name>
                        <wd:Organization_Type_Reference>
                          <wd:ID wd:type="WID">3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d</wd:ID>
                          <wd:ID wd:type="Organization_Type_ID">Company</wd:ID>
                        </wd:Organization_Type_Reference>
                      </wd:Organization_Data>
                    </wd:Worker_Organization_Data>
                  </wd:Organization_Data>

                </wd:Position_Data>

                <!-- Manager Reference -->
                <wd:Manager_as_of_last_detected_manager_change_Reference>
                  <wd:ID wd:type="WID">aabbccdd11223344556677889900aabb</wd:ID>
                  <wd:ID wd:type="Employee_ID">100089</wd:ID>
                </wd:Manager_as_of_last_detected_manager_change_Reference>

                <!-- Worker Status (Active, Hire Date, etc.) -->
                <wd:Worker_Status_Data>
                  <wd:Active>true</wd:Active>
                  <wd:Active_Status_Date>2021-03-15</wd:Active_Status_Date>
                  <wd:Hire_Date>2021-03-15</wd:Hire_Date>
                  <wd:Original_Hire_Date>2021-03-15</wd:Original_Hire_Date>
                  <wd:End_Employment_Date/>
                  <wd:Continuous_Service_Date>2021-03-15</wd:Continuous_Service_Date>
                  <wd:First_Day_of_Work>2021-03-15</wd:First_Day_of_Work>
                  <wd:Seniority_Date>2021-03-15</wd:Seniority_Date>
                  <wd:Benefits_Service_Date>2021-03-15</wd:Benefits_Service_Date>
                  <wd:Company_Service_Date>2021-03-15</wd:Company_Service_Date>
                  <wd:Retired>false</wd:Retired>
                  <wd:Terminated>false</wd:Terminated>
                  <wd:Rehire>false</wd:Rehire>
                  <wd:Days_Unemployed>0</wd:Days_Unemployed>
                  <wd:Not_Returning>false</wd:Not_Returning>
                  <wd:Probation_Start_Date>2021-03-15</wd:Probation_Start_Date>
                  <wd:Probation_End_Date>2021-09-15</wd:Probation_End_Date>
                </wd:Worker_Status_Data>

              </wd:Worker_Job_Data>

              <!-- International Assignment (empty for this worker) -->
              <wd:Worker_Job_Data>
                <!-- Additional positions would appear as additional Worker_Job_Data elements -->
                <!-- This worker has only one position, so only one appears above -->
              </wd:Worker_Job_Data>

            </wd:Employment_Data>

          </wd:Worker_Data>
        </wd:Worker>

        <!-- ============================================================ -->
        <!-- WORKER 2 — Terminated Employee (tests your parser edge case) -->
        <!-- ============================================================ -->
        <wd:Worker>
          <wd:Worker_Reference>
            <wd:ID wd:type="WID">8dd7761e9bf54ac7b011e5c23d70fa92</wd:ID>
            <wd:ID wd:type="Employee_ID">100578</wd:ID>
          </wd:Worker_Reference>

          <wd:Worker_Data>
            <wd:Worker_ID>100578</wd:Worker_ID>
            <wd:User_ID>rgarcia</wd:User_ID>

            <!-- ======================================================== -->
            <!-- PERSONAL DATA                                             -->
            <!-- ======================================================== -->
            <wd:Personal_Data>

              <wd:Name_Data>
                <wd:Legal_Name_Data>
                  <wd:Name_Detail_Data>
                    <wd:Country_Reference>
                      <wd:ID wd:type="WID">bc33aa3152ec42d4995f4791a106ed09</wd:ID>
                      <wd:ID wd:type="ISO_3166-1_Alpha-2_Code">US</wd:ID>
                      <wd:ID wd:type="ISO_3166-1_Alpha-3_Code">USA</wd:ID>
                    </wd:Country_Reference>
                    <wd:First_Name>Roberto</wd:First_Name>
                    <wd:Last_Name>Garcia</wd:Last_Name>
                    <wd:Formatted_Name>Roberto Garcia</wd:Formatted_Name>
                    <wd:Reporting_Name>Garcia, Roberto</wd:Reporting_Name>
                  </wd:Name_Detail_Data>
                </wd:Legal_Name_Data>
                <wd:Preferred_Name_Data>
                  <wd:Name_Detail_Data>
                    <wd:Country_Reference>
                      <wd:ID wd:type="WID">bc33aa3152ec42d4995f4791a106ed09</wd:ID>
                      <wd:ID wd:type="ISO_3166-1_Alpha-2_Code">US</wd:ID>
                    </wd:Country_Reference>
                    <wd:First_Name>Rob</wd:First_Name>
                    <wd:Last_Name>Garcia</wd:Last_Name>
                    <wd:Formatted_Name>Rob Garcia</wd:Formatted_Name>
                    <wd:Reporting_Name>Garcia, Rob</wd:Reporting_Name>
                  </wd:Name_Detail_Data>
                </wd:Preferred_Name_Data>
              </wd:Name_Data>

              <wd:Contact_Data>

                <!-- Work Email -->
                <wd:Email_Address_Data>
                  <wd:Email_Address>roberto.garcia@acmecorp.com</wd:Email_Address>
                  <wd:Usage_Data wd:Public="true">
                    <wd:Type_Data wd:Primary="true">
                      <wd:Type_Reference>
                        <wd:ID wd:type="WID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</wd:ID>
                        <wd:ID wd:type="Communication_Usage_Type_ID">WORK</wd:ID>
                      </wd:Type_Reference>
                    </wd:Type_Data>
                  </wd:Usage_Data>
                </wd:Email_Address_Data>

                <!-- Work Phone -->
                <wd:Phone_Data>
                  <wd:International_Phone_Code>1</wd:International_Phone_Code>
                  <wd:Area_Code>512</wd:Area_Code>
                  <wd:Phone_Number>555-0377</wd:Phone_Number>
                  <wd:Phone_Device_Type_Reference>
                    <wd:ID wd:type="WID">e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9</wd:ID>
                    <wd:ID wd:type="Phone_Device_Type_ID">Landline</wd:ID>
                  </wd:Phone_Device_Type_Reference>
                  <wd:Usage_Data wd:Public="true">
                    <wd:Type_Data wd:Primary="true">
                      <wd:Type_Reference>
                        <wd:ID wd:type="WID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</wd:ID>
                        <wd:ID wd:type="Communication_Usage_Type_ID">WORK</wd:ID>
                      </wd:Type_Reference>
                    </wd:Type_Data>
                  </wd:Usage_Data>
                  <wd:Formatted_Phone>+1 (512) 555-0377</wd:Formatted_Phone>
                </wd:Phone_Data>

                <!-- Home Address -->
                <wd:Address_Data>
                  <wd:Country_Reference>
                    <wd:ID wd:type="WID">bc33aa3152ec42d4995f4791a106ed09</wd:ID>
                    <wd:ID wd:type="ISO_3166-1_Alpha-2_Code">US</wd:ID>
                  </wd:Country_Reference>
                  <wd:Last_Modified>2023-11-01T14:22:00.000-05:00</wd:Last_Modified>
                  <wd:Address_Line_Data wd:Type="ADDRESS_LINE_1">2200 Congress Avenue</wd:Address_Line_Data>
                  <wd:Municipality>Austin</wd:Municipality>
                  <wd:Country_Region_Reference>
                    <wd:ID wd:type="WID">b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e4</wd:ID>
                    <wd:ID wd:type="Country_Region_ID">USA-TX</wd:ID>
                  </wd:Country_Region_Reference>
                  <wd:Country_Region_Descriptor>Texas</wd:Country_Region_Descriptor>
                  <wd:Postal_Code>78701</wd:Postal_Code>
                  <wd:Formatted_Address>2200 Congress Avenue, Austin, TX 78701, United States of America</wd:Formatted_Address>
                  <wd:Defaulted_Business_Site_Address>false</wd:Defaulted_Business_Site_Address>
                  <wd:Usage_Data wd:Public="false">
                    <wd:Type_Data wd:Primary="true">
                      <wd:Type_Reference>
                        <wd:ID wd:type="WID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</wd:ID>
                        <wd:ID wd:type="Communication_Usage_Type_ID">HOME</wd:ID>
                      </wd:Type_Reference>
                    </wd:Type_Data>
                  </wd:Usage_Data>
                </wd:Address_Data>

              </wd:Contact_Data>

              <wd:Biographical_Data>
                <wd:Date_of_Birth>1992-11-03</wd:Date_of_Birth>
                <wd:Gender_Reference>
                  <wd:ID wd:type="WID">0a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d</wd:ID>
                  <wd:ID wd:type="Gender_ID">Male</wd:ID>
                </wd:Gender_Reference>
                <wd:Country_of_Birth_Reference>
                  <wd:ID wd:type="WID">bc33aa3152ec42d4995f4791a106ed09</wd:ID>
                  <wd:ID wd:type="ISO_3166-1_Alpha-2_Code">US</wd:ID>
                </wd:Country_of_Birth_Reference>
                <wd:Marital_Status_Reference>
                  <wd:ID wd:type="WID">d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0</wd:ID>
                  <wd:ID wd:type="Marital_Status_ID">Single</wd:ID>
                </wd:Marital_Status_Reference>
              </wd:Biographical_Data>

              <wd:Identification_Data>
                <wd:National_ID>
                  <wd:National_ID_Data>
                    <wd:ID>***-**-4321</wd:ID>
                    <wd:ID_Type_Reference>
                      <wd:ID wd:type="WID">e8f9a0b1c2d3e4f5a6b7c8d9e0f1a2b3</wd:ID>
                      <wd:ID wd:type="National_ID_Type_Code">USA-SSN</wd:ID>
                    </wd:ID_Type_Reference>
                    <wd:Country_Reference>
                      <wd:ID wd:type="WID">bc33aa3152ec42d4995f4791a106ed09</wd:ID>
                      <wd:ID wd:type="ISO_3166-1_Alpha-2_Code">US</wd:ID>
                    </wd:Country_Reference>
                  </wd:National_ID_Data>
                </wd:National_ID>
              </wd:Identification_Data>

            </wd:Personal_Data>

            <!-- ======================================================== -->
            <!-- EMPLOYMENT DATA                                           -->
            <!-- ======================================================== -->
            <wd:Employment_Data>

              <wd:Worker_Job_Data>
                <wd:Position_Data>
                  <wd:Position_ID>P-003887</wd:Position_ID>
                  <wd:Position_Title>Financial Analyst</wd:Position_Title>
                  <wd:Business_Title>Financial Analyst II</wd:Business_Title>
                  <wd:Start_Date>2022-06-01</wd:Start_Date>
                  <wd:End_Date>2025-12-20</wd:End_Date>
                  <wd:Default_Weekly_Hours>40</wd:Default_Weekly_Hours>
                  <wd:Scheduled_Weekly_Hours>40</wd:Scheduled_Weekly_Hours>
                  <wd:Full_Time_Equivalent_Percentage>100</wd:Full_Time_Equivalent_Percentage>

                  <wd:Position_Reference>
                    <wd:ID wd:type="WID">ccd8e9f0a1b2c3d4e5f6a7b8c9d0e1f2</wd:ID>
                    <wd:ID wd:type="Position_ID">P-003887</wd:ID>
                  </wd:Position_Reference>

                  <wd:Worker_Type_Reference>
                    <wd:ID wd:type="WID">d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9</wd:ID>
                    <wd:ID wd:type="Worker_Type_ID">Regular</wd:ID>
                  </wd:Worker_Type_Reference>

                  <wd:Job_Profile_Summary_Data>
                    <wd:Job_Profile_Reference>
                      <wd:ID wd:type="WID">aa11bb22cc33dd44ee55ff6600778899</wd:ID>
                      <wd:ID wd:type="Job_Profile_ID">JP-FIN-ANL</wd:ID>
                    </wd:Job_Profile_Reference>
                    <wd:Job_Profile_Name>Financial Analyst</wd:Job_Profile_Name>
                    <wd:Management_Level_Reference>
                      <wd:ID wd:type="WID">2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e</wd:ID>
                      <wd:ID wd:type="Management_Level_ID">Individual_Contributor</wd:ID>
                    </wd:Management_Level_Reference>
                    <wd:Job_Category_Reference>
                      <wd:ID wd:type="WID">bb22cc33dd44ee55ff66007788990011</wd:ID>
                      <wd:ID wd:type="Job_Category_ID">Finance</wd:ID>
                    </wd:Job_Category_Reference>
                    <wd:Job_Family_Reference>
                      <wd:ID wd:type="WID">cc33dd44ee55ff660077889900112233</wd:ID>
                      <wd:ID wd:type="Job_Family_ID">JF-Finance</wd:ID>
                    </wd:Job_Family_Reference>
                  </wd:Job_Profile_Summary_Data>

                  <wd:Business_Site_Summary_Data>
                    <wd:Name>Austin Office</wd:Name>
                    <wd:Location_Reference>
                      <wd:ID wd:type="WID">dd44ee55ff66007788990011223344aa</wd:ID>
                      <wd:ID wd:type="Location_ID">LOC-AUS-01</wd:ID>
                    </wd:Location_Reference>
                    <wd:Location_Type_Reference>
                      <wd:ID wd:type="WID">6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c</wd:ID>
                      <wd:ID wd:type="Location_Type_ID">Office</wd:ID>
                    </wd:Location_Type_Reference>
                    <wd:Address_Data>
                      <wd:Country_Reference>
                        <wd:ID wd:type="ISO_3166-1_Alpha-2_Code">US</wd:ID>
                      </wd:Country_Reference>
                      <wd:Address_Line_Data wd:Type="ADDRESS_LINE_1">500 West 2nd Street</wd:Address_Line_Data>
                      <wd:Address_Line_Data wd:Type="ADDRESS_LINE_2">Floor 12</wd:Address_Line_Data>
                      <wd:Municipality>Austin</wd:Municipality>
                      <wd:Country_Region_Reference>
                        <wd:ID wd:type="Country_Region_ID">USA-TX</wd:ID>
                      </wd:Country_Region_Reference>
                      <wd:Country_Region_Descriptor>Texas</wd:Country_Region_Descriptor>
                      <wd:Postal_Code>78701</wd:Postal_Code>
                    </wd:Address_Data>
                  </wd:Business_Site_Summary_Data>

                  <wd:Pay_Rate_Type_Reference>
                    <wd:ID wd:type="WID">7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d</wd:ID>
                    <wd:ID wd:type="Pay_Rate_Type_ID">Salary</wd:ID>
                  </wd:Pay_Rate_Type_Reference>

                  <wd:Position_Time_Type_Reference>
                    <wd:ID wd:type="WID">8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e</wd:ID>
                    <wd:ID wd:type="Position_Time_Type_ID">Full_time</wd:ID>
                  </wd:Position_Time_Type_Reference>

                  <wd:Supervisory_Organization_Reference>
                    <wd:ID wd:type="WID">ee55ff660077889900112233445566bb</wd:ID>
                    <wd:ID wd:type="Organization_Reference_ID">FIN-CORP-001</wd:ID>
                  </wd:Supervisory_Organization_Reference>

                  <wd:Organization_Data>
                    <wd:Worker_Organization_Data>
                      <wd:Organization_Data>
                        <wd:Organization_Reference>
                          <wd:ID wd:type="WID">ff660077889900112233445566778899</wd:ID>
                          <wd:ID wd:type="Organization_Reference_ID">CC-3200</wd:ID>
                          <wd:ID wd:type="Cost_Center_Reference_ID">CC-3200</wd:ID>
                        </wd:Organization_Reference>
                        <wd:Organization_Name>Finance - Corporate</wd:Organization_Name>
                        <wd:Organization_Type_Reference>
                          <wd:ID wd:type="WID">1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b</wd:ID>
                          <wd:ID wd:type="Organization_Type_ID">Cost_Center</wd:ID>
                        </wd:Organization_Type_Reference>
                      </wd:Organization_Data>
                      <wd:Organization_Data>
                        <wd:Organization_Reference>
                          <wd:ID wd:type="WID">2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c</wd:ID>
                          <wd:ID wd:type="Organization_Reference_ID">COMP-ACME</wd:ID>
                          <wd:ID wd:type="Company_Reference_ID">COMP-ACME</wd:ID>
                        </wd:Organization_Reference>
                        <wd:Organization_Name>Acme Corporation</wd:Organization_Name>
                        <wd:Organization_Type_Reference>
                          <wd:ID wd:type="WID">3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d</wd:ID>
                          <wd:ID wd:type="Organization_Type_ID">Company</wd:ID>
                        </wd:Organization_Type_Reference>
                      </wd:Organization_Data>
                    </wd:Worker_Organization_Data>
                  </wd:Organization_Data>

                </wd:Position_Data>

                <wd:Manager_as_of_last_detected_manager_change_Reference>
                  <wd:ID wd:type="WID">1122334455667788990011aabbccddee</wd:ID>
                  <wd:ID wd:type="Employee_ID">100102</wd:ID>
                </wd:Manager_as_of_last_detected_manager_change_Reference>

                <wd:Worker_Status_Data>
                  <wd:Active>false</wd:Active>
                  <wd:Active_Status_Date>2022-06-01</wd:Active_Status_Date>
                  <wd:Hire_Date>2022-06-01</wd:Hire_Date>
                  <wd:Original_Hire_Date>2022-06-01</wd:Original_Hire_Date>
                  <wd:End_Employment_Date>2025-12-20</wd:End_Employment_Date>
                  <wd:Continuous_Service_Date>2022-06-01</wd:Continuous_Service_Date>
                  <wd:First_Day_of_Work>2022-06-01</wd:First_Day_of_Work>
                  <wd:Seniority_Date>2022-06-01</wd:Seniority_Date>
                  <wd:Benefits_Service_Date>2022-06-01</wd:Benefits_Service_Date>
                  <wd:Company_Service_Date>2022-06-01</wd:Company_Service_Date>
                  <wd:Retired>false</wd:Retired>
                  <wd:Terminated>true</wd:Terminated>
                  <wd:Termination_Date>2025-12-20</wd:Termination_Date>
                  <wd:Pay_Through_Date>2025-12-31</wd:Pay_Through_Date>
                  <wd:Termination_Category_Reference>
                    <wd:ID wd:type="WID">aabb1122ccdd3344eeff5566aabb7788</wd:ID>
                    <wd:ID wd:type="Termination_Category_ID">Voluntary</wd:ID>
                  </wd:Termination_Category_Reference>
                  <wd:Primary_Termination_Reason_Reference>
                    <wd:ID wd:type="WID">ccdd3344eeff5566aabb778899001122</wd:ID>
                    <wd:ID wd:type="Termination_Reason_ID">Resignation - New Opportunity</wd:ID>
                  </wd:Primary_Termination_Reason_Reference>
                  <wd:Rehire>false</wd:Rehire>
                  <wd:Days_Unemployed>0</wd:Days_Unemployed>
                  <wd:Not_Returning>true</wd:Not_Returning>
                  <wd:Resignation_Date>2025-11-20</wd:Resignation_Date>
                  <wd:Last_Day_of_Work>2025-12-19</wd:Last_Day_of_Work>
                  <wd:Eligible_for_Rehire_Reference>
                    <wd:ID wd:type="WID">eeff5566aabb778899001122ccdd3344</wd:ID>
                    <wd:ID wd:type="Eligible_for_Rehire_ID">Yes</wd:ID>
                  </wd:Eligible_for_Rehire_Reference>
                </wd:Worker_Status_Data>

              </wd:Worker_Job_Data>

            </wd:Employment_Data>

          </wd:Worker_Data>
        </wd:Worker>

      </wd:Response_Data>
    </wd:Get_Workers_Response>
  </env:Body>
</env:Envelope>"}
\ No newline at end of file
+{"xml":"<?xml version="1.0" encoding="UTF-8"?>
<soap:Envelope
    xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
    xmlns:xhr="urn:com.xylophonichr/api">
  <soap:Body>
    <xhr:GetEmployees_Response xhr:version="v12.0">

      <!-- ============================================================ -->
      <!-- PAGINATION METADATA                                          -->
      <!-- ============================================================ -->
      <xhr:Response_Filter>
        <xhr:Effective_As_Of_Date>2026-03-30</xhr:Effective_As_Of_Date>
        <xhr:Effective_As_Of_DateTime>2026-03-30T12:00:00.000-07:00</xhr:Effective_As_Of_DateTime>
        <xhr:Page>1</xhr:Page>
        <xhr:Page_Size>100</xhr:Page_Size>
      </xhr:Response_Filter>

      <xhr:Response_Summary>
        <xhr:Total_Records>4</xhr:Total_Records>
        <xhr:Total_Pages>1</xhr:Total_Pages>
        <xhr:Records_On_Page>4</xhr:Records_On_Page>
        <xhr:Current_Page>1</xhr:Current_Page>
      </xhr:Response_Summary>

      <xhr:Response_Data>

        <!-- ============================================================ -->
        <!-- EMPLOYEE 1 — Active, Full-Time, US-based                     -->
        <!-- ============================================================ -->
        <xhr:Employee>
          <xhr:Employee_Reference>
            <xhr:ID xhr:type="GID">a4c9e17f2b6d48a3901e7c5f83d2b0a6</xhr:ID>
            <xhr:ID xhr:type="Employee_Number">EMP-204817</xhr:ID>
          </xhr:Employee_Reference>

          <xhr:Employee_Data>
            <xhr:Employee_Number>EMP-204817</xhr:Employee_Number>
            <xhr:Login_ID>kpatel</xhr:Login_ID>

            <!-- ======================================================== -->
            <!-- PERSONAL DATA                                             -->
            <!-- ======================================================== -->
            <xhr:Personal_Data>

              <xhr:Name_Data>
                <xhr:Legal_Name>
                  <xhr:Name_Detail>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha3">USA</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:Title>Ms.</xhr:Title>
                    <xhr:First_Name>Kavita</xhr:First_Name>
                    <xhr:Middle_Name>Rani</xhr:Middle_Name>
                    <xhr:Last_Name>Patel</xhr:Last_Name>
                    <xhr:Suffix/>
                    <xhr:Display_Name>Kavita Rani Patel</xhr:Display_Name>
                    <xhr:Sort_Name>Patel, Kavita Rani</xhr:Sort_Name>
                  </xhr:Name_Detail>
                </xhr:Legal_Name>
                <xhr:Preferred_Name>
                  <xhr:Name_Detail>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:First_Name>Kavita</xhr:First_Name>
                    <xhr:Last_Name>Patel</xhr:Last_Name>
                    <xhr:Display_Name>Kavita Patel</xhr:Display_Name>
                    <xhr:Sort_Name>Patel, Kavita</xhr:Sort_Name>
                  </xhr:Name_Detail>
                </xhr:Preferred_Name>
              </xhr:Name_Data>

              <xhr:Contact_Data>

                <!-- Work Email -->
                <xhr:Email>
                  <xhr:Email_Address>kavita.patel@globaldynamics.com</xhr:Email_Address>
                  <xhr:Usage xhr:Public="true">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">WORK</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                </xhr:Email>

                <!-- Personal Email -->
                <xhr:Email>
                  <xhr:Email_Address>kavita.r.patel@outlook.com</xhr:Email_Address>
                  <xhr:Usage xhr:Public="false">
                    <xhr:Type_Info xhr:Primary="false">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">HOME</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                </xhr:Email>

                <!-- Work Phone -->
                <xhr:Phone>
                  <xhr:Country_Code>1</xhr:Country_Code>
                  <xhr:Area_Code>415</xhr:Area_Code>
                  <xhr:Number>555-0132</xhr:Number>
                  <xhr:Extension>4420</xhr:Extension>
                  <xhr:Device_Type_Reference>
                    <xhr:ID xhr:type="GID">e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9</xhr:ID>
                    <xhr:ID xhr:type="Device_Type_Code">Landline</xhr:ID>
                  </xhr:Device_Type_Reference>
                  <xhr:Usage xhr:Public="true">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">WORK</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                  <xhr:Formatted_Number>+1 (415) 555-0132 x4420</xhr:Formatted_Number>
                </xhr:Phone>

                <!-- Mobile Phone -->
                <xhr:Phone>
                  <xhr:Country_Code>1</xhr:Country_Code>
                  <xhr:Area_Code>650</xhr:Area_Code>
                  <xhr:Number>555-0278</xhr:Number>
                  <xhr:Device_Type_Reference>
                    <xhr:ID xhr:type="GID">f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0</xhr:ID>
                    <xhr:ID xhr:type="Device_Type_Code">Mobile</xhr:ID>
                  </xhr:Device_Type_Reference>
                  <xhr:Usage xhr:Public="false">
                    <xhr:Type_Info xhr:Primary="false">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">HOME</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                  <xhr:Formatted_Number>+1 (650) 555-0278</xhr:Formatted_Number>
                </xhr:Phone>

                <!-- Home Address -->
                <xhr:Address>
                  <xhr:Country_Reference>
                    <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                    <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                  </xhr:Country_Reference>
                  <xhr:Last_Modified>2025-01-10T08:15:00.000-08:00</xhr:Last_Modified>
                  <xhr:Line xhr:Type="LINE_1">1847 Lombard Street</xhr:Line>
                  <xhr:Line xhr:Type="LINE_2">Unit 6</xhr:Line>
                  <xhr:City>San Francisco</xhr:City>
                  <xhr:Region_Reference>
                    <xhr:ID xhr:type="GID">a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3</xhr:ID>
                    <xhr:ID xhr:type="Region_Code">USA-CA</xhr:ID>
                  </xhr:Region_Reference>
                  <xhr:Region_Name>California</xhr:Region_Name>
                  <xhr:Postal_Code>94123</xhr:Postal_Code>
                  <xhr:Formatted_Address>1847 Lombard Street, Unit 6, San Francisco, CA 94123, United States of America</xhr:Formatted_Address>
                  <xhr:Is_Business_Site_Default>false</xhr:Is_Business_Site_Default>
                  <xhr:Usage xhr:Public="false">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">HOME</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                </xhr:Address>

              </xhr:Contact_Data>

              <xhr:Biographical_Data>
                <xhr:Date_of_Birth>1990-04-18</xhr:Date_of_Birth>
                <xhr:Gender_Reference>
                  <xhr:ID xhr:type="GID">9a0b1c2d3e4f5a6b7c8d9e0f1a2b3c4d</xhr:ID>
                  <xhr:ID xhr:type="Gender_Code">Female</xhr:ID>
                </xhr:Gender_Reference>
                <xhr:Country_of_Birth_Reference>
                  <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                  <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                </xhr:Country_of_Birth_Reference>
                <xhr:Marital_Status_Reference>
                  <xhr:ID xhr:type="GID">c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9</xhr:ID>
                  <xhr:ID xhr:type="Marital_Status_Code">Married</xhr:ID>
                </xhr:Marital_Status_Reference>
                <xhr:Marital_Status_Date>2020-08-15</xhr:Marital_Status_Date>
              </xhr:Biographical_Data>

              <xhr:Identification_Data>
                <xhr:National_ID>
                  <xhr:National_ID_Detail>
                    <xhr:Value>***-**-7890</xhr:Value>
                    <xhr:ID_Type_Reference>
                      <xhr:ID xhr:type="GID">e8f9a0b1c2d3e4f5a6b7c8d9e0f1a2b3</xhr:ID>
                      <xhr:ID xhr:type="National_ID_Type">USA-SSN</xhr:ID>
                    </xhr:ID_Type_Reference>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:Issued_Date>2008-06-20</xhr:Issued_Date>
                  </xhr:National_ID_Detail>
                </xhr:National_ID>
                <xhr:Custom_ID>
                  <xhr:Custom_ID_Detail>
                    <xhr:Value>BADGE-10482</xhr:Value>
                    <xhr:ID_Type_Reference>
                      <xhr:ID xhr:type="GID">f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6</xhr:ID>
                      <xhr:ID xhr:type="Custom_ID_Type">Badge_ID</xhr:ID>
                    </xhr:ID_Type_Reference>
                  </xhr:Custom_ID_Detail>
                </xhr:Custom_ID>
                <xhr:Custom_ID>
                  <xhr:Custom_ID_Detail>
                    <xhr:Value>PKT-0091</xhr:Value>
                    <xhr:ID_Type_Reference>
                      <xhr:ID xhr:type="GID">a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7</xhr:ID>
                      <xhr:ID xhr:type="Custom_ID_Type">Parking_Permit</xhr:ID>
                    </xhr:ID_Type_Reference>
                  </xhr:Custom_ID_Detail>
                </xhr:Custom_ID>
              </xhr:Identification_Data>

            </xhr:Personal_Data>

            <!-- ======================================================== -->
            <!-- EMPLOYMENT DATA                                           -->
            <!-- ======================================================== -->
            <xhr:Employment_Data>
              <xhr:Job_Data>
                <xhr:Position>
                  <xhr:Position_ID>POS-009213</xhr:Position_ID>
                  <xhr:Position_Title>Principal Data Engineer</xhr:Position_Title>
                  <xhr:Business_Title>Principal Data Engineer</xhr:Business_Title>
                  <xhr:Start_Date>2024-02-12</xhr:Start_Date>
                  <xhr:Default_Weekly_Hours>40</xhr:Default_Weekly_Hours>
                  <xhr:Scheduled_Weekly_Hours>40</xhr:Scheduled_Weekly_Hours>
                  <xhr:FTE_Percentage>100</xhr:FTE_Percentage>

                  <xhr:Position_Reference>
                    <xhr:ID xhr:type="GID">7bc6640c8af459c6bf99d4b02c59d001</xhr:ID>
                    <xhr:ID xhr:type="Position_ID">POS-009213</xhr:ID>
                  </xhr:Position_Reference>

                  <xhr:Employee_Type_Reference>
                    <xhr:ID xhr:type="GID">d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9</xhr:ID>
                    <xhr:ID xhr:type="Employee_Type_Code">Regular</xhr:ID>
                  </xhr:Employee_Type_Reference>

                  <xhr:Job_Profile>
                    <xhr:Job_Profile_Reference>
                      <xhr:ID xhr:type="GID">1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d</xhr:ID>
                      <xhr:ID xhr:type="Job_Profile_Code">JP-DATA-ENG-P</xhr:ID>
                    </xhr:Job_Profile_Reference>
                    <xhr:Job_Profile_Name>Principal Data Engineer</xhr:Job_Profile_Name>
                    <xhr:Management_Level_Reference>
                      <xhr:ID xhr:type="GID">2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e</xhr:ID>
                      <xhr:ID xhr:type="Management_Level_Code">Individual_Contributor</xhr:ID>
                    </xhr:Management_Level_Reference>
                    <xhr:Job_Category_Reference>
                      <xhr:ID xhr:type="GID">3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f</xhr:ID>
                      <xhr:ID xhr:type="Job_Category_Code">Engineering</xhr:ID>
                    </xhr:Job_Category_Reference>
                    <xhr:Job_Family_Reference>
                      <xhr:ID xhr:type="GID">4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a</xhr:ID>
                      <xhr:ID xhr:type="Job_Family_Code">JF-Data-Engineering</xhr:ID>
                    </xhr:Job_Family_Reference>
                  </xhr:Job_Profile>

                  <xhr:Work_Location>
                    <xhr:Location_Name>San Francisco HQ</xhr:Location_Name>
                    <xhr:Location_Reference>
                      <xhr:ID xhr:type="GID">5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b</xhr:ID>
                      <xhr:ID xhr:type="Location_Code">LOC-SF-HQ</xhr:ID>
                    </xhr:Location_Reference>
                    <xhr:Location_Type_Reference>
                      <xhr:ID xhr:type="GID">6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c</xhr:ID>
                      <xhr:ID xhr:type="Location_Type_Code">Office</xhr:ID>
                    </xhr:Location_Type_Reference>
                    <xhr:Address>
                      <xhr:Country_Reference>
                        <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                      </xhr:Country_Reference>
                      <xhr:Line xhr:Type="LINE_1">350 Mission Street</xhr:Line>
                      <xhr:Line xhr:Type="LINE_2">Floor 22</xhr:Line>
                      <xhr:City>San Francisco</xhr:City>
                      <xhr:Region_Reference>
                        <xhr:ID xhr:type="Region_Code">USA-CA</xhr:ID>
                      </xhr:Region_Reference>
                      <xhr:Region_Name>California</xhr:Region_Name>
                      <xhr:Postal_Code>94105</xhr:Postal_Code>
                    </xhr:Address>
                  </xhr:Work_Location>

                  <xhr:Pay_Rate_Type_Reference>
                    <xhr:ID xhr:type="GID">7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d</xhr:ID>
                    <xhr:ID xhr:type="Pay_Rate_Type_Code">Salary</xhr:ID>
                  </xhr:Pay_Rate_Type_Reference>

                  <xhr:Time_Type_Reference>
                    <xhr:ID xhr:type="GID">8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e</xhr:ID>
                    <xhr:ID xhr:type="Time_Type_Code">Full_Time</xhr:ID>
                  </xhr:Time_Type_Reference>

                  <xhr:Supervisory_Org_Reference>
                    <xhr:ID xhr:type="GID">9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f</xhr:ID>
                    <xhr:ID xhr:type="Org_Code">ENG-DATA-001</xhr:ID>
                  </xhr:Supervisory_Org_Reference>

                  <xhr:Organization_Assignments>
                    <xhr:Organization>
                      <xhr:Organization_Reference>
                        <xhr:ID xhr:type="GID">0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a</xhr:ID>
                        <xhr:ID xhr:type="Org_Code">CC-7100</xhr:ID>
                        <xhr:ID xhr:type="Cost_Center_Code">CC-7100</xhr:ID>
                      </xhr:Organization_Reference>
                      <xhr:Organization_Name>Engineering - Data Platform</xhr:Organization_Name>
                      <xhr:Organization_Type_Reference>
                        <xhr:ID xhr:type="GID">1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b</xhr:ID>
                        <xhr:ID xhr:type="Org_Type_Code">Cost_Center</xhr:ID>
                      </xhr:Organization_Type_Reference>
                    </xhr:Organization>
                    <xhr:Organization>
                      <xhr:Organization_Reference>
                        <xhr:ID xhr:type="GID">2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c</xhr:ID>
                        <xhr:ID xhr:type="Org_Code">COMP-GD</xhr:ID>
                        <xhr:ID xhr:type="Company_Code">COMP-GD</xhr:ID>
                      </xhr:Organization_Reference>
                      <xhr:Organization_Name>Global Dynamics Inc.</xhr:Organization_Name>
                      <xhr:Organization_Type_Reference>
                        <xhr:ID xhr:type="GID">3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d</xhr:ID>
                        <xhr:ID xhr:type="Org_Type_Code">Company</xhr:ID>
                      </xhr:Organization_Type_Reference>
                    </xhr:Organization>
                    <xhr:Organization>
                      <xhr:Organization_Reference>
                        <xhr:ID xhr:type="GID">4a5b6c7d8e9f0a1b2c3d4e5f6a7b8c9d</xhr:ID>
                        <xhr:ID xhr:type="Org_Code">REG-WEST</xhr:ID>
                        <xhr:ID xhr:type="Region_Org_Code">REG-WEST</xhr:ID>
                      </xhr:Organization_Reference>
                      <xhr:Organization_Name>Western Region</xhr:Organization_Name>
                      <xhr:Organization_Type_Reference>
                        <xhr:ID xhr:type="GID">5b6c7d8e9f0a1b2c3d4e5f6a7b8c9d0e</xhr:ID>
                        <xhr:ID xhr:type="Org_Type_Code">Region</xhr:ID>
                      </xhr:Organization_Type_Reference>
                    </xhr:Organization>
                  </xhr:Organization_Assignments>

                </xhr:Position>

                <xhr:Manager_Reference>
                  <xhr:ID xhr:type="GID">aabbccdd11223344556677889900aabb</xhr:ID>
                  <xhr:ID xhr:type="Employee_Number">EMP-198044</xhr:ID>
                </xhr:Manager_Reference>

                <xhr:Employment_Status>
                  <xhr:Is_Active>true</xhr:Is_Active>
                  <xhr:Active_Status_Date>2022-08-01</xhr:Active_Status_Date>
                  <xhr:Hire_Date>2022-08-01</xhr:Hire_Date>
                  <xhr:Original_Hire_Date>2022-08-01</xhr:Original_Hire_Date>
                  <xhr:End_Employment_Date/>
                  <xhr:Continuous_Service_Date>2022-08-01</xhr:Continuous_Service_Date>
                  <xhr:First_Day_of_Work>2022-08-01</xhr:First_Day_of_Work>
                  <xhr:Seniority_Date>2022-08-01</xhr:Seniority_Date>
                  <xhr:Benefits_Service_Date>2022-08-01</xhr:Benefits_Service_Date>
                  <xhr:Company_Service_Date>2022-08-01</xhr:Company_Service_Date>
                  <xhr:Is_Retired>false</xhr:Is_Retired>
                  <xhr:Is_Terminated>false</xhr:Is_Terminated>
                  <xhr:Is_Rehire>false</xhr:Is_Rehire>
                  <xhr:Days_Unemployed>0</xhr:Days_Unemployed>
                  <xhr:Probation_Start_Date>2022-08-01</xhr:Probation_Start_Date>
                  <xhr:Probation_End_Date>2023-02-01</xhr:Probation_End_Date>
                </xhr:Employment_Status>

              </xhr:Job_Data>
            </xhr:Employment_Data>

          </xhr:Employee_Data>
        </xhr:Employee>

        <!-- ============================================================ -->
        <!-- EMPLOYEE 2 — Terminated (Voluntary Resignation)              -->
        <!-- ============================================================ -->
        <xhr:Employee>
          <xhr:Employee_Reference>
            <xhr:ID xhr:type="GID">8dd7761e9bf54ac7b011e5c23d70fa92</xhr:ID>
            <xhr:ID xhr:type="Employee_Number">EMP-187293</xhr:ID>
          </xhr:Employee_Reference>

          <xhr:Employee_Data>
            <xhr:Employee_Number>EMP-187293</xhr:Employee_Number>
            <xhr:Login_ID>tchen</xhr:Login_ID>

            <xhr:Personal_Data>
              <xhr:Name_Data>
                <xhr:Legal_Name>
                  <xhr:Name_Detail>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha3">USA</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:First_Name>Tao</xhr:First_Name>
                    <xhr:Last_Name>Chen</xhr:Last_Name>
                    <xhr:Display_Name>Tao Chen</xhr:Display_Name>
                    <xhr:Sort_Name>Chen, Tao</xhr:Sort_Name>
                  </xhr:Name_Detail>
                </xhr:Legal_Name>
                <xhr:Preferred_Name>
                  <xhr:Name_Detail>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:First_Name>Tao</xhr:First_Name>
                    <xhr:Last_Name>Chen</xhr:Last_Name>
                    <xhr:Display_Name>Tao Chen</xhr:Display_Name>
                    <xhr:Sort_Name>Chen, Tao</xhr:Sort_Name>
                  </xhr:Name_Detail>
                </xhr:Preferred_Name>
              </xhr:Name_Data>

              <xhr:Contact_Data>
                <xhr:Email>
                  <xhr:Email_Address>tao.chen@globaldynamics.com</xhr:Email_Address>
                  <xhr:Usage xhr:Public="true">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">WORK</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                </xhr:Email>

                <xhr:Phone>
                  <xhr:Country_Code>1</xhr:Country_Code>
                  <xhr:Area_Code>312</xhr:Area_Code>
                  <xhr:Number>555-0491</xhr:Number>
                  <xhr:Device_Type_Reference>
                    <xhr:ID xhr:type="GID">e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9</xhr:ID>
                    <xhr:ID xhr:type="Device_Type_Code">Landline</xhr:ID>
                  </xhr:Device_Type_Reference>
                  <xhr:Usage xhr:Public="true">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">WORK</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                  <xhr:Formatted_Number>+1 (312) 555-0491</xhr:Formatted_Number>
                </xhr:Phone>

                <xhr:Address>
                  <xhr:Country_Reference>
                    <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                    <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                  </xhr:Country_Reference>
                  <xhr:Last_Modified>2024-03-22T10:45:00.000-06:00</xhr:Last_Modified>
                  <xhr:Line xhr:Type="LINE_1">440 North Wabash Avenue</xhr:Line>
                  <xhr:Line xhr:Type="LINE_2">Apt 2701</xhr:Line>
                  <xhr:City>Chicago</xhr:City>
                  <xhr:Region_Reference>
                    <xhr:ID xhr:type="GID">c0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f5</xhr:ID>
                    <xhr:ID xhr:type="Region_Code">USA-IL</xhr:ID>
                  </xhr:Region_Reference>
                  <xhr:Region_Name>Illinois</xhr:Region_Name>
                  <xhr:Postal_Code>60611</xhr:Postal_Code>
                  <xhr:Formatted_Address>440 North Wabash Avenue, Apt 2701, Chicago, IL 60611, United States of America</xhr:Formatted_Address>
                  <xhr:Is_Business_Site_Default>false</xhr:Is_Business_Site_Default>
                  <xhr:Usage xhr:Public="false">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">HOME</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                </xhr:Address>
              </xhr:Contact_Data>

              <xhr:Biographical_Data>
                <xhr:Date_of_Birth>1985-12-09</xhr:Date_of_Birth>
                <xhr:Gender_Reference>
                  <xhr:ID xhr:type="GID">0a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d</xhr:ID>
                  <xhr:ID xhr:type="Gender_Code">Male</xhr:ID>
                </xhr:Gender_Reference>
                <xhr:Country_of_Birth_Reference>
                  <xhr:ID xhr:type="GID">dd44ee55ff66007788990011223344bb</xhr:ID>
                  <xhr:ID xhr:type="ISO_3166_Alpha2">CN</xhr:ID>
                </xhr:Country_of_Birth_Reference>
                <xhr:Marital_Status_Reference>
                  <xhr:ID xhr:type="GID">c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9</xhr:ID>
                  <xhr:ID xhr:type="Marital_Status_Code">Married</xhr:ID>
                </xhr:Marital_Status_Reference>
                <xhr:Marital_Status_Date>2015-05-20</xhr:Marital_Status_Date>
              </xhr:Biographical_Data>

              <xhr:Identification_Data>
                <xhr:National_ID>
                  <xhr:National_ID_Detail>
                    <xhr:Value>***-**-3456</xhr:Value>
                    <xhr:ID_Type_Reference>
                      <xhr:ID xhr:type="GID">e8f9a0b1c2d3e4f5a6b7c8d9e0f1a2b3</xhr:ID>
                      <xhr:ID xhr:type="National_ID_Type">USA-SSN</xhr:ID>
                    </xhr:ID_Type_Reference>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                    </xhr:Country_Reference>
                  </xhr:National_ID_Detail>
                </xhr:National_ID>
              </xhr:Identification_Data>

            </xhr:Personal_Data>

            <xhr:Employment_Data>
              <xhr:Job_Data>
                <xhr:Position>
                  <xhr:Position_ID>POS-006744</xhr:Position_ID>
                  <xhr:Position_Title>Marketing Manager</xhr:Position_Title>
                  <xhr:Business_Title>Senior Marketing Manager</xhr:Business_Title>
                  <xhr:Start_Date>2023-03-01</xhr:Start_Date>
                  <xhr:End_Date>2026-01-15</xhr:End_Date>
                  <xhr:Default_Weekly_Hours>40</xhr:Default_Weekly_Hours>
                  <xhr:Scheduled_Weekly_Hours>40</xhr:Scheduled_Weekly_Hours>
                  <xhr:FTE_Percentage>100</xhr:FTE_Percentage>

                  <xhr:Position_Reference>
                    <xhr:ID xhr:type="GID">ccd8e9f0a1b2c3d4e5f6a7b8c9d0e1f2</xhr:ID>
                    <xhr:ID xhr:type="Position_ID">POS-006744</xhr:ID>
                  </xhr:Position_Reference>

                  <xhr:Employee_Type_Reference>
                    <xhr:ID xhr:type="GID">d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9</xhr:ID>
                    <xhr:ID xhr:type="Employee_Type_Code">Regular</xhr:ID>
                  </xhr:Employee_Type_Reference>

                  <xhr:Job_Profile>
                    <xhr:Job_Profile_Reference>
                      <xhr:ID xhr:type="GID">aa11bb22cc33dd44ee55ff6600778899</xhr:ID>
                      <xhr:ID xhr:type="Job_Profile_Code">JP-MKT-MGR</xhr:ID>
                    </xhr:Job_Profile_Reference>
                    <xhr:Job_Profile_Name>Marketing Manager</xhr:Job_Profile_Name>
                    <xhr:Management_Level_Reference>
                      <xhr:ID xhr:type="GID">6c7d8e9f0a1b2c3d4e5f6a7b8c9d0e1f</xhr:ID>
                      <xhr:ID xhr:type="Management_Level_Code">Manager</xhr:ID>
                    </xhr:Management_Level_Reference>
                    <xhr:Job_Category_Reference>
                      <xhr:ID xhr:type="GID">bb22cc33dd44ee55ff66007788990011</xhr:ID>
                      <xhr:ID xhr:type="Job_Category_Code">Marketing</xhr:ID>
                    </xhr:Job_Category_Reference>
                    <xhr:Job_Family_Reference>
                      <xhr:ID xhr:type="GID">cc33dd44ee55ff660077889900112233</xhr:ID>
                      <xhr:ID xhr:type="Job_Family_Code">JF-Marketing</xhr:ID>
                    </xhr:Job_Family_Reference>
                  </xhr:Job_Profile>

                  <xhr:Work_Location>
                    <xhr:Location_Name>Chicago Office</xhr:Location_Name>
                    <xhr:Location_Reference>
                      <xhr:ID xhr:type="GID">dd44ee55ff66007788990011223344aa</xhr:ID>
                      <xhr:ID xhr:type="Location_Code">LOC-CHI-01</xhr:ID>
                    </xhr:Location_Reference>
                    <xhr:Location_Type_Reference>
                      <xhr:ID xhr:type="GID">6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c</xhr:ID>
                      <xhr:ID xhr:type="Location_Type_Code">Office</xhr:ID>
                    </xhr:Location_Type_Reference>
                    <xhr:Address>
                      <xhr:Country_Reference>
                        <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                      </xhr:Country_Reference>
                      <xhr:Line xhr:Type="LINE_1">233 South Wacker Drive</xhr:Line>
                      <xhr:Line xhr:Type="LINE_2">Suite 4800</xhr:Line>
                      <xhr:City>Chicago</xhr:City>
                      <xhr:Region_Reference>
                        <xhr:ID xhr:type="Region_Code">USA-IL</xhr:ID>
                      </xhr:Region_Reference>
                      <xhr:Region_Name>Illinois</xhr:Region_Name>
                      <xhr:Postal_Code>60606</xhr:Postal_Code>
                    </xhr:Address>
                  </xhr:Work_Location>

                  <xhr:Pay_Rate_Type_Reference>
                    <xhr:ID xhr:type="GID">7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d</xhr:ID>
                    <xhr:ID xhr:type="Pay_Rate_Type_Code">Salary</xhr:ID>
                  </xhr:Pay_Rate_Type_Reference>

                  <xhr:Time_Type_Reference>
                    <xhr:ID xhr:type="GID">8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e</xhr:ID>
                    <xhr:ID xhr:type="Time_Type_Code">Full_Time</xhr:ID>
                  </xhr:Time_Type_Reference>

                  <xhr:Supervisory_Org_Reference>
                    <xhr:ID xhr:type="GID">ee55ff660077889900112233445566bb</xhr:ID>
                    <xhr:ID xhr:type="Org_Code">MKT-BRAND-001</xhr:ID>
                  </xhr:Supervisory_Org_Reference>

                  <xhr:Organization_Assignments>
                    <xhr:Organization>
                      <xhr:Organization_Reference>
                        <xhr:ID xhr:type="GID">ff660077889900112233445566778899</xhr:ID>
                        <xhr:ID xhr:type="Org_Code">CC-5200</xhr:ID>
                        <xhr:ID xhr:type="Cost_Center_Code">CC-5200</xhr:ID>
                      </xhr:Organization_Reference>
                      <xhr:Organization_Name>Marketing - Brand</xhr:Organization_Name>
                      <xhr:Organization_Type_Reference>
                        <xhr:ID xhr:type="GID">1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b</xhr:ID>
                        <xhr:ID xhr:type="Org_Type_Code">Cost_Center</xhr:ID>
                      </xhr:Organization_Type_Reference>
                    </xhr:Organization>
                    <xhr:Organization>
                      <xhr:Organization_Reference>
                        <xhr:ID xhr:type="GID">2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c</xhr:ID>
                        <xhr:ID xhr:type="Org_Code">COMP-GD</xhr:ID>
                        <xhr:ID xhr:type="Company_Code">COMP-GD</xhr:ID>
                      </xhr:Organization_Reference>
                      <xhr:Organization_Name>Global Dynamics Inc.</xhr:Organization_Name>
                      <xhr:Organization_Type_Reference>
                        <xhr:ID xhr:type="GID">3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d</xhr:ID>
                        <xhr:ID xhr:type="Org_Type_Code">Company</xhr:ID>
                      </xhr:Organization_Type_Reference>
                    </xhr:Organization>
                  </xhr:Organization_Assignments>

                </xhr:Position>

                <xhr:Manager_Reference>
                  <xhr:ID xhr:type="GID">1122334455667788990011aabbccddee</xhr:ID>
                  <xhr:ID xhr:type="Employee_Number">EMP-176002</xhr:ID>
                </xhr:Manager_Reference>

                <xhr:Employment_Status>
                  <xhr:Is_Active>false</xhr:Is_Active>
                  <xhr:Active_Status_Date>2021-09-15</xhr:Active_Status_Date>
                  <xhr:Hire_Date>2021-09-15</xhr:Hire_Date>
                  <xhr:Original_Hire_Date>2021-09-15</xhr:Original_Hire_Date>
                  <xhr:End_Employment_Date>2026-01-15</xhr:End_Employment_Date>
                  <xhr:Continuous_Service_Date>2021-09-15</xhr:Continuous_Service_Date>
                  <xhr:First_Day_of_Work>2021-09-15</xhr:First_Day_of_Work>
                  <xhr:Seniority_Date>2021-09-15</xhr:Seniority_Date>
                  <xhr:Benefits_Service_Date>2021-09-15</xhr:Benefits_Service_Date>
                  <xhr:Company_Service_Date>2021-09-15</xhr:Company_Service_Date>
                  <xhr:Is_Retired>false</xhr:Is_Retired>
                  <xhr:Is_Terminated>true</xhr:Is_Terminated>
                  <xhr:Termination_Date>2026-01-15</xhr:Termination_Date>
                  <xhr:Pay_Through_Date>2026-01-31</xhr:Pay_Through_Date>
                  <xhr:Termination_Category_Reference>
                    <xhr:ID xhr:type="GID">aabb1122ccdd3344eeff5566aabb7788</xhr:ID>
                    <xhr:ID xhr:type="Termination_Category_Code">Voluntary</xhr:ID>
                  </xhr:Termination_Category_Reference>
                  <xhr:Primary_Termination_Reason_Reference>
                    <xhr:ID xhr:type="GID">ccdd3344eeff5566aabb778899001122</xhr:ID>
                    <xhr:ID xhr:type="Termination_Reason_Code">Resignation_New_Opportunity</xhr:ID>
                  </xhr:Primary_Termination_Reason_Reference>
                  <xhr:Is_Rehire>false</xhr:Is_Rehire>
                  <xhr:Days_Unemployed>0</xhr:Days_Unemployed>
                  <xhr:Not_Returning>true</xhr:Not_Returning>
                  <xhr:Resignation_Date>2025-12-15</xhr:Resignation_Date>
                  <xhr:Last_Day_of_Work>2026-01-14</xhr:Last_Day_of_Work>
                  <xhr:Eligible_for_Rehire_Reference>
                    <xhr:ID xhr:type="GID">eeff5566aabb778899001122ccdd3344</xhr:ID>
                    <xhr:ID xhr:type="Rehire_Eligibility_Code">Yes</xhr:ID>
                  </xhr:Eligible_for_Rehire_Reference>
                </xhr:Employment_Status>

              </xhr:Job_Data>
            </xhr:Employment_Data>

          </xhr:Employee_Data>
        </xhr:Employee>

        <!-- ============================================================ -->
        <!-- EMPLOYEE 3 — Active, On Leave (Parental)                     -->
        <!-- ============================================================ -->
        <xhr:Employee>
          <xhr:Employee_Reference>
            <xhr:ID xhr:type="GID">f7e6d5c4b3a2918070605040302010ff</xhr:ID>
            <xhr:ID xhr:type="Employee_Number">EMP-211305</xhr:ID>
          </xhr:Employee_Reference>

          <xhr:Employee_Data>
            <xhr:Employee_Number>EMP-211305</xhr:Employee_Number>
            <xhr:Login_ID>sjohansson</xhr:Login_ID>

            <xhr:Personal_Data>
              <xhr:Name_Data>
                <xhr:Legal_Name>
                  <xhr:Name_Detail>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">ee44ff5500667788991122334455aabb</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">SE</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha3">SWE</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:First_Name>Sofia</xhr:First_Name>
                    <xhr:Middle_Name>Linnéa</xhr:Middle_Name>
                    <xhr:Last_Name>Johansson</xhr:Last_Name>
                    <xhr:Display_Name>Sofia Linnéa Johansson</xhr:Display_Name>
                    <xhr:Sort_Name>Johansson, Sofia Linnéa</xhr:Sort_Name>
                  </xhr:Name_Detail>
                </xhr:Legal_Name>
                <xhr:Preferred_Name>
                  <xhr:Name_Detail>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:First_Name>Sofia</xhr:First_Name>
                    <xhr:Last_Name>Johansson</xhr:Last_Name>
                    <xhr:Display_Name>Sofia Johansson</xhr:Display_Name>
                    <xhr:Sort_Name>Johansson, Sofia</xhr:Sort_Name>
                  </xhr:Name_Detail>
                </xhr:Preferred_Name>
              </xhr:Name_Data>

              <xhr:Contact_Data>
                <xhr:Email>
                  <xhr:Email_Address>sofia.johansson@globaldynamics.com</xhr:Email_Address>
                  <xhr:Usage xhr:Public="true">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">WORK</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                </xhr:Email>

                <xhr:Email>
                  <xhr:Email_Address>sofia.johansson@proton.me</xhr:Email_Address>
                  <xhr:Usage xhr:Public="false">
                    <xhr:Type_Info xhr:Primary="false">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">HOME</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                </xhr:Email>

                <xhr:Phone>
                  <xhr:Country_Code>1</xhr:Country_Code>
                  <xhr:Area_Code>206</xhr:Area_Code>
                  <xhr:Number>555-0834</xhr:Number>
                  <xhr:Device_Type_Reference>
                    <xhr:ID xhr:type="GID">f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0</xhr:ID>
                    <xhr:ID xhr:type="Device_Type_Code">Mobile</xhr:ID>
                  </xhr:Device_Type_Reference>
                  <xhr:Usage xhr:Public="false">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">HOME</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                  <xhr:Formatted_Number>+1 (206) 555-0834</xhr:Formatted_Number>
                </xhr:Phone>

                <xhr:Address>
                  <xhr:Country_Reference>
                    <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                    <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                  </xhr:Country_Reference>
                  <xhr:Last_Modified>2025-06-01T11:00:00.000-08:00</xhr:Last_Modified>
                  <xhr:Line xhr:Type="LINE_1">3014 NE 55th Street</xhr:Line>
                  <xhr:City>Seattle</xhr:City>
                  <xhr:Region_Reference>
                    <xhr:ID xhr:type="GID">d1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6</xhr:ID>
                    <xhr:ID xhr:type="Region_Code">USA-WA</xhr:ID>
                  </xhr:Region_Reference>
                  <xhr:Region_Name>Washington</xhr:Region_Name>
                  <xhr:Postal_Code>98105</xhr:Postal_Code>
                  <xhr:Formatted_Address>3014 NE 55th Street, Seattle, WA 98105, United States of America</xhr:Formatted_Address>
                  <xhr:Is_Business_Site_Default>false</xhr:Is_Business_Site_Default>
                  <xhr:Usage xhr:Public="false">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">HOME</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                </xhr:Address>
              </xhr:Contact_Data>

              <xhr:Biographical_Data>
                <xhr:Date_of_Birth>1993-02-14</xhr:Date_of_Birth>
                <xhr:Gender_Reference>
                  <xhr:ID xhr:type="GID">9a0b1c2d3e4f5a6b7c8d9e0f1a2b3c4d</xhr:ID>
                  <xhr:ID xhr:type="Gender_Code">Female</xhr:ID>
                </xhr:Gender_Reference>
                <xhr:Country_of_Birth_Reference>
                  <xhr:ID xhr:type="GID">ee44ff5500667788991122334455aabb</xhr:ID>
                  <xhr:ID xhr:type="ISO_3166_Alpha2">SE</xhr:ID>
                </xhr:Country_of_Birth_Reference>
                <xhr:Marital_Status_Reference>
                  <xhr:ID xhr:type="GID">e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1</xhr:ID>
                  <xhr:ID xhr:type="Marital_Status_Code">Domestic_Partnership</xhr:ID>
                </xhr:Marital_Status_Reference>
                <xhr:Marital_Status_Date>2023-01-10</xhr:Marital_Status_Date>
              </xhr:Biographical_Data>

              <xhr:Identification_Data>
                <xhr:National_ID>
                  <xhr:National_ID_Detail>
                    <xhr:Value>***-**-5512</xhr:Value>
                    <xhr:ID_Type_Reference>
                      <xhr:ID xhr:type="GID">e8f9a0b1c2d3e4f5a6b7c8d9e0f1a2b3</xhr:ID>
                      <xhr:ID xhr:type="National_ID_Type">USA-SSN</xhr:ID>
                    </xhr:ID_Type_Reference>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                    </xhr:Country_Reference>
                  </xhr:National_ID_Detail>
                </xhr:National_ID>
                <!-- Note: also holds a Swedish personal identity number -->
                <xhr:National_ID>
                  <xhr:National_ID_Detail>
                    <xhr:Value>930214-XXXX</xhr:Value>
                    <xhr:ID_Type_Reference>
                      <xhr:ID xhr:type="GID">a0b1c2d3e4f5a6b7c8d9e0f1a2b3c4d5</xhr:ID>
                      <xhr:ID xhr:type="National_ID_Type">SWE-PIN</xhr:ID>
                    </xhr:ID_Type_Reference>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">ee44ff5500667788991122334455aabb</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">SE</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:Issued_Date>1993-02-14</xhr:Issued_Date>
                  </xhr:National_ID_Detail>
                </xhr:National_ID>
              </xhr:Identification_Data>

            </xhr:Personal_Data>

            <xhr:Employment_Data>
              <xhr:Job_Data>
                <xhr:Position>
                  <xhr:Position_ID>POS-010881</xhr:Position_ID>
                  <xhr:Position_Title>UX Research Lead</xhr:Position_Title>
                  <xhr:Business_Title>UX Research Lead</xhr:Business_Title>
                  <xhr:Start_Date>2024-06-01</xhr:Start_Date>
                  <xhr:Default_Weekly_Hours>40</xhr:Default_Weekly_Hours>
                  <xhr:Scheduled_Weekly_Hours>0</xhr:Scheduled_Weekly_Hours>
                  <xhr:FTE_Percentage>100</xhr:FTE_Percentage>

                  <xhr:Position_Reference>
                    <xhr:ID xhr:type="GID">1122aabb3344ccdd5566eeff7788a1b2</xhr:ID>
                    <xhr:ID xhr:type="Position_ID">POS-010881</xhr:ID>
                  </xhr:Position_Reference>

                  <xhr:Employee_Type_Reference>
                    <xhr:ID xhr:type="GID">d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9</xhr:ID>
                    <xhr:ID xhr:type="Employee_Type_Code">Regular</xhr:ID>
                  </xhr:Employee_Type_Reference>

                  <xhr:Job_Profile>
                    <xhr:Job_Profile_Reference>
                      <xhr:ID xhr:type="GID">bb11cc22dd33ee44ff550066778899aa</xhr:ID>
                      <xhr:ID xhr:type="Job_Profile_Code">JP-UXR-LEAD</xhr:ID>
                    </xhr:Job_Profile_Reference>
                    <xhr:Job_Profile_Name>UX Research Lead</xhr:Job_Profile_Name>
                    <xhr:Management_Level_Reference>
                      <xhr:ID xhr:type="GID">6c7d8e9f0a1b2c3d4e5f6a7b8c9d0e1f</xhr:ID>
                      <xhr:ID xhr:type="Management_Level_Code">Manager</xhr:ID>
                    </xhr:Management_Level_Reference>
                    <xhr:Job_Category_Reference>
                      <xhr:ID xhr:type="GID">cc22dd33ee44ff5500667788990011bb</xhr:ID>
                      <xhr:ID xhr:type="Job_Category_Code">Design</xhr:ID>
                    </xhr:Job_Category_Reference>
                    <xhr:Job_Family_Reference>
                      <xhr:ID xhr:type="GID">dd33ee44ff550066778899001122ccbb</xhr:ID>
                      <xhr:ID xhr:type="Job_Family_Code">JF-Design-Research</xhr:ID>
                    </xhr:Job_Family_Reference>
                  </xhr:Job_Profile>

                  <xhr:Work_Location>
                    <xhr:Location_Name>Seattle Office</xhr:Location_Name>
                    <xhr:Location_Reference>
                      <xhr:ID xhr:type="GID">ee44ff55006677889911223344556677</xhr:ID>
                      <xhr:ID xhr:type="Location_Code">LOC-SEA-01</xhr:ID>
                    </xhr:Location_Reference>
                    <xhr:Location_Type_Reference>
                      <xhr:ID xhr:type="GID">6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c</xhr:ID>
                      <xhr:ID xhr:type="Location_Type_Code">Office</xhr:ID>
                    </xhr:Location_Type_Reference>
                    <xhr:Address>
                      <xhr:Country_Reference>
                        <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                      </xhr:Country_Reference>
                      <xhr:Line xhr:Type="LINE_1">701 Pike Street</xhr:Line>
                      <xhr:Line xhr:Type="LINE_2">Floor 8</xhr:Line>
                      <xhr:City>Seattle</xhr:City>
                      <xhr:Region_Reference>
                        <xhr:ID xhr:type="Region_Code">USA-WA</xhr:ID>
                      </xhr:Region_Reference>
                      <xhr:Region_Name>Washington</xhr:Region_Name>
                      <xhr:Postal_Code>98101</xhr:Postal_Code>
                    </xhr:Address>
                  </xhr:Work_Location>

                  <xhr:Pay_Rate_Type_Reference>
                    <xhr:ID xhr:type="GID">7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d</xhr:ID>
                    <xhr:ID xhr:type="Pay_Rate_Type_Code">Salary</xhr:ID>
                  </xhr:Pay_Rate_Type_Reference>

                  <xhr:Time_Type_Reference>
                    <xhr:ID xhr:type="GID">8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e</xhr:ID>
                    <xhr:ID xhr:type="Time_Type_Code">Full_Time</xhr:ID>
                  </xhr:Time_Type_Reference>

                  <xhr:Supervisory_Org_Reference>
                    <xhr:ID xhr:type="GID">ff5500667788990011223344556677aa</xhr:ID>
                    <xhr:ID xhr:type="Org_Code">DES-RESEARCH-001</xhr:ID>
                  </xhr:Supervisory_Org_Reference>

                  <xhr:Organization_Assignments>
                    <xhr:Organization>
                      <xhr:Organization_Reference>
                        <xhr:ID xhr:type="GID">00667788990011223344556677889900</xhr:ID>
                        <xhr:ID xhr:type="Org_Code">CC-8300</xhr:ID>
                        <xhr:ID xhr:type="Cost_Center_Code">CC-8300</xhr:ID>
                      </xhr:Organization_Reference>
                      <xhr:Organization_Name>Design - Research</xhr:Organization_Name>
                      <xhr:Organization_Type_Reference>
                        <xhr:ID xhr:type="GID">1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b</xhr:ID>
                        <xhr:ID xhr:type="Org_Type_Code">Cost_Center</xhr:ID>
                      </xhr:Organization_Type_Reference>
                    </xhr:Organization>
                    <xhr:Organization>
                      <xhr:Organization_Reference>
                        <xhr:ID xhr:type="GID">2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c</xhr:ID>
                        <xhr:ID xhr:type="Org_Code">COMP-GD</xhr:ID>
                        <xhr:ID xhr:type="Company_Code">COMP-GD</xhr:ID>
                      </xhr:Organization_Reference>
                      <xhr:Organization_Name>Global Dynamics Inc.</xhr:Organization_Name>
                      <xhr:Organization_Type_Reference>
                        <xhr:ID xhr:type="GID">3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d</xhr:ID>
                        <xhr:ID xhr:type="Org_Type_Code">Company</xhr:ID>
                      </xhr:Organization_Type_Reference>
                    </xhr:Organization>
                  </xhr:Organization_Assignments>

                </xhr:Position>

                <xhr:Manager_Reference>
                  <xhr:ID xhr:type="GID">2233445566778899aabb0011ccddeeff</xhr:ID>
                  <xhr:ID xhr:type="Employee_Number">EMP-201440</xhr:ID>
                </xhr:Manager_Reference>

                <xhr:Employment_Status>
                  <xhr:Is_Active>true</xhr:Is_Active>
                  <xhr:Active_Status_Date>2023-04-10</xhr:Active_Status_Date>
                  <xhr:Hire_Date>2023-04-10</xhr:Hire_Date>
                  <xhr:Original_Hire_Date>2023-04-10</xhr:Original_Hire_Date>
                  <xhr:End_Employment_Date/>
                  <xhr:Continuous_Service_Date>2023-04-10</xhr:Continuous_Service_Date>
                  <xhr:First_Day_of_Work>2023-04-10</xhr:First_Day_of_Work>
                  <xhr:Seniority_Date>2023-04-10</xhr:Seniority_Date>
                  <xhr:Benefits_Service_Date>2023-04-10</xhr:Benefits_Service_Date>
                  <xhr:Company_Service_Date>2023-04-10</xhr:Company_Service_Date>
                  <xhr:Is_Retired>false</xhr:Is_Retired>
                  <xhr:Is_Terminated>false</xhr:Is_Terminated>
                  <xhr:Is_Rehire>false</xhr:Is_Rehire>
                  <xhr:Days_Unemployed>0</xhr:Days_Unemployed>
                  <!-- Leave of Absence fields — only present when on leave -->
                  <xhr:On_Leave>true</xhr:On_Leave>
                  <xhr:Leave_Start_Date>2026-02-03</xhr:Leave_Start_Date>
                  <xhr:Expected_Return_Date>2026-08-03</xhr:Expected_Return_Date>
                  <xhr:Leave_Type_Reference>
                    <xhr:ID xhr:type="GID">7788990011223344556677aabbccdd00</xhr:ID>
                    <xhr:ID xhr:type="Leave_Type_Code">Parental_Leave</xhr:ID>
                  </xhr:Leave_Type_Reference>
                  <xhr:Leave_Request_Reference>
                    <xhr:ID xhr:type="GID">8899001122334455667788aabbccdd11</xhr:ID>
                    <xhr:ID xhr:type="Leave_Request_ID">LR-2026-000412</xhr:ID>
                  </xhr:Leave_Request_Reference>
                </xhr:Employment_Status>

              </xhr:Job_Data>
            </xhr:Employment_Data>

          </xhr:Employee_Data>
        </xhr:Employee>

        <!-- ============================================================ -->
        <!-- EMPLOYEE 4 — Contingent Worker (Contractor)                  -->
        <!-- ============================================================ -->
        <xhr:Employee>
          <xhr:Employee_Reference>
            <xhr:ID xhr:type="GID">0102030405060708090a0b0c0d0e0f10</xhr:ID>
            <xhr:ID xhr:type="Contingent_Worker_Number">CW-400091</xhr:ID>
          </xhr:Employee_Reference>

          <xhr:Employee_Data>
            <xhr:Employee_Number>CW-400091</xhr:Employee_Number>
            <xhr:Login_ID>mnakamura.ext</xhr:Login_ID>

            <xhr:Personal_Data>
              <xhr:Name_Data>
                <xhr:Legal_Name>
                  <xhr:Name_Detail>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">ff00112233445566778899aabbccddee</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">JP</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha3">JPN</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:First_Name>Masato</xhr:First_Name>
                    <xhr:Last_Name>Nakamura</xhr:Last_Name>
                    <xhr:Display_Name>Masato Nakamura</xhr:Display_Name>
                    <xhr:Sort_Name>Nakamura, Masato</xhr:Sort_Name>
                  </xhr:Name_Detail>
                </xhr:Legal_Name>
                <xhr:Preferred_Name>
                  <xhr:Name_Detail>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:First_Name>Masa</xhr:First_Name>
                    <xhr:Last_Name>Nakamura</xhr:Last_Name>
                    <xhr:Display_Name>Masa Nakamura</xhr:Display_Name>
                    <xhr:Sort_Name>Nakamura, Masa</xhr:Sort_Name>
                  </xhr:Name_Detail>
                </xhr:Preferred_Name>
              </xhr:Name_Data>

              <xhr:Contact_Data>
                <xhr:Email>
                  <xhr:Email_Address>masato.nakamura.ext@globaldynamics.com</xhr:Email_Address>
                  <xhr:Usage xhr:Public="true">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">WORK</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                </xhr:Email>

                <xhr:Phone>
                  <xhr:Country_Code>1</xhr:Country_Code>
                  <xhr:Area_Code>408</xhr:Area_Code>
                  <xhr:Number>555-0612</xhr:Number>
                  <xhr:Device_Type_Reference>
                    <xhr:ID xhr:type="GID">f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0</xhr:ID>
                    <xhr:ID xhr:type="Device_Type_Code">Mobile</xhr:ID>
                  </xhr:Device_Type_Reference>
                  <xhr:Usage xhr:Public="true">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">WORK</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                  <xhr:Formatted_Number>+1 (408) 555-0612</xhr:Formatted_Number>
                </xhr:Phone>

                <!-- Note: No home address on file for contingent workers — common pattern -->

              </xhr:Contact_Data>

              <xhr:Biographical_Data>
                <xhr:Date_of_Birth>1987-09-30</xhr:Date_of_Birth>
                <xhr:Gender_Reference>
                  <xhr:ID xhr:type="GID">0a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d</xhr:ID>
                  <xhr:ID xhr:type="Gender_Code">Male</xhr:ID>
                </xhr:Gender_Reference>
                <xhr:Country_of_Birth_Reference>
                  <xhr:ID xhr:type="GID">ff00112233445566778899aabbccddee</xhr:ID>
                  <xhr:ID xhr:type="ISO_3166_Alpha2">JP</xhr:ID>
                </xhr:Country_of_Birth_Reference>
                <!-- No marital status — not collected for contingent workers -->
              </xhr:Biographical_Data>

              <xhr:Identification_Data>
                <!-- Contingent workers may have no national IDs on file -->
                <xhr:Custom_ID>
                  <xhr:Custom_ID_Detail>
                    <xhr:Value>VENDOR-TECHSTAR-0091</xhr:Value>
                    <xhr:ID_Type_Reference>
                      <xhr:ID xhr:type="GID">b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8</xhr:ID>
                      <xhr:ID xhr:type="Custom_ID_Type">Vendor_Worker_ID</xhr:ID>
                    </xhr:ID_Type_Reference>
                  </xhr:Custom_ID_Detail>
                </xhr:Custom_ID>
                <xhr:Custom_ID>
                  <xhr:Custom_ID_Detail>
                    <xhr:Value>BADGE-EXT-7721</xhr:Value>
                    <xhr:ID_Type_Reference>
                      <xhr:ID xhr:type="GID">f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6</xhr:ID>
                      <xhr:ID xhr:type="Custom_ID_Type">Badge_ID</xhr:ID>
                    </xhr:ID_Type_Reference>
                  </xhr:Custom_ID_Detail>
                </xhr:Custom_ID>
              </xhr:Identification_Data>

            </xhr:Personal_Data>

            <xhr:Employment_Data>
              <xhr:Job_Data>
                <xhr:Position>
                  <xhr:Position_ID>POS-CW-0412</xhr:Position_ID>
                  <xhr:Position_Title>Staff Augmentation - DevOps</xhr:Position_Title>
                  <xhr:Business_Title>DevOps Engineer (Contract)</xhr:Business_Title>
                  <xhr:Start_Date>2025-10-01</xhr:Start_Date>
                  <xhr:End_Date>2026-09-30</xhr:End_Date>
                  <xhr:Default_Weekly_Hours>40</xhr:Default_Weekly_Hours>
                  <xhr:Scheduled_Weekly_Hours>40</xhr:Scheduled_Weekly_Hours>
                  <xhr:FTE_Percentage>100</xhr:FTE_Percentage>

                  <xhr:Position_Reference>
                    <xhr:ID xhr:type="GID">aabb0011ccdd2233eeff4455667788cc</xhr:ID>
                    <xhr:ID xhr:type="Position_ID">POS-CW-0412</xhr:ID>
                  </xhr:Position_Reference>

                  <xhr:Employee_Type_Reference>
                    <xhr:ID xhr:type="GID">e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0</xhr:ID>
                    <xhr:ID xhr:type="Employee_Type_Code">Contingent_Worker</xhr:ID>
                  </xhr:Employee_Type_Reference>

                  <xhr:Job_Profile>
                    <xhr:Job_Profile_Reference>
                      <xhr:ID xhr:type="GID">cc11dd22ee33ff440055667788990011</xhr:ID>
                      <xhr:ID xhr:type="Job_Profile_Code">JP-DEVOPS-CW</xhr:ID>
                    </xhr:Job_Profile_Reference>
                    <xhr:Job_Profile_Name>DevOps Engineer (Contract)</xhr:Job_Profile_Name>
                    <xhr:Management_Level_Reference>
                      <xhr:ID xhr:type="GID">2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e</xhr:ID>
                      <xhr:ID xhr:type="Management_Level_Code">Individual_Contributor</xhr:ID>
                    </xhr:Management_Level_Reference>
                    <xhr:Job_Category_Reference>
                      <xhr:ID xhr:type="GID">3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f</xhr:ID>
                      <xhr:ID xhr:type="Job_Category_Code">Engineering</xhr:ID>
                    </xhr:Job_Category_Reference>
                    <xhr:Job_Family_Reference>
                      <xhr:ID xhr:type="GID">ee44ff5500667788990011223344aabb</xhr:ID>
                      <xhr:ID xhr:type="Job_Family_Code">JF-Infrastructure</xhr:ID>
                    </xhr:Job_Family_Reference>
                  </xhr:Job_Profile>

                  <xhr:Work_Location>
                    <xhr:Location_Name>San Francisco HQ</xhr:Location_Name>
                    <xhr:Location_Reference>
                      <xhr:ID xhr:type="GID">5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b</xhr:ID>
                      <xhr:ID xhr:type="Location_Code">LOC-SF-HQ</xhr:ID>
                    </xhr:Location_Reference>
                    <xhr:Location_Type_Reference>
                      <xhr:ID xhr:type="GID">6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c</xhr:ID>
                      <xhr:ID xhr:type="Location_Type_Code">Office</xhr:ID>
                    </xhr:Location_Type_Reference>
                    <xhr:Address>
                      <xhr:Country_Reference>
                        <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                      </xhr:Country_Reference>
                      <xhr:Line xhr:Type="LINE_1">350 Mission Street</xhr:Line>
                      <xhr:Line xhr:Type="LINE_2">Floor 22</xhr:Line>
                      <xhr:City>San Francisco</xhr:City>
                      <xhr:Region_Reference>
                        <xhr:ID xhr:type="Region_Code">USA-CA</xhr:ID>
                      </xhr:Region_Reference>
                      <xhr:Region_Name>California</xhr:Region_Name>
                      <xhr:Postal_Code>94105</xhr:Postal_Code>
                    </xhr:Address>
                  </xhr:Work_Location>

                  <xhr:Pay_Rate_Type_Reference>
                    <xhr:ID xhr:type="GID">9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f</xhr:ID>
                    <xhr:ID xhr:type="Pay_Rate_Type_Code">Hourly</xhr:ID>
                  </xhr:Pay_Rate_Type_Reference>

                  <xhr:Time_Type_Reference>
                    <xhr:ID xhr:type="GID">8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e</xhr:ID>
                    <xhr:ID xhr:type="Time_Type_Code">Full_Time</xhr:ID>
                  </xhr:Time_Type_Reference>

                  <xhr:Supervisory_Org_Reference>
                    <xhr:ID xhr:type="GID">9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f</xhr:ID>
                    <xhr:ID xhr:type="Org_Code">ENG-DATA-001</xhr:ID>
                  </xhr:Supervisory_Org_Reference>

                  <!-- Vendor / Staffing Agency reference — unique to contingent workers -->
                  <xhr:Staffing_Agency_Reference>
                    <xhr:ID xhr:type="GID">1100aabb2233ccdd4455eeff66778800</xhr:ID>
                    <xhr:ID xhr:type="Vendor_Code">VENDOR-TECHSTAR</xhr:ID>
                  </xhr:Staffing_Agency_Reference>

                  <xhr:Organization_Assignments>
                    <xhr:Organization>
                      <xhr:Organization_Reference>
                        <xhr:ID xhr:type="GID">0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a</xhr:ID>
                        <xhr:ID xhr:type="Org_Code">CC-7100</xhr:ID>
                        <xhr:ID xhr:type="Cost_Center_Code">CC-7100</xhr:ID>
                      </xhr:Organization_Reference>
                      <xhr:Organization_Name>Engineering - Data Platform</xhr:Organization_Name>
                      <xhr:Organization_Type_Reference>
                        <xhr:ID xhr:type="GID">1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b</xhr:ID>
                        <xhr:ID xhr:type="Org_Type_Code">Cost_Center</xhr:ID>
                      </xhr:Organization_Type_Reference>
                    </xhr:Organization>
                    <xhr:Organization>
                      <xhr:Organization_Reference>
                        <xhr:ID xhr:type="GID">2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c</xhr:ID>
                        <xhr:ID xhr:type="Org_Code">COMP-GD</xhr:ID>
                        <xhr:ID xhr:type="Company_Code">COMP-GD</xhr:ID>
                      </xhr:Organization_Reference>
                      <xhr:Organization_Name>Global Dynamics Inc.</xhr:Organization_Name>
                      <xhr:Organization_Type_Reference>
                        <xhr:ID xhr:type="GID">3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d</xhr:ID>
                        <xhr:ID xhr:type="Org_Type_Code">Company</xhr:ID>
                      </xhr:Organization_Type_Reference>
                    </xhr:Organization>
                  </xhr:Organization_Assignments>

                </xhr:Position>

                <xhr:Manager_Reference>
                  <xhr:ID xhr:type="GID">aabbccdd11223344556677889900aabb</xhr:ID>
                  <xhr:ID xhr:type="Employee_Number">EMP-198044</xhr:ID>
                </xhr:Manager_Reference>

                <xhr:Employment_Status>
                  <xhr:Is_Active>true</xhr:Is_Active>
                  <xhr:Active_Status_Date>2025-10-01</xhr:Active_Status_Date>
                  <xhr:Hire_Date>2025-10-01</xhr:Hire_Date>
                  <xhr:Original_Hire_Date>2025-10-01</xhr:Original_Hire_Date>
                  <xhr:End_Employment_Date>2026-09-30</xhr:End_Employment_Date>
                  <xhr:Continuous_Service_Date>2025-10-01</xhr:Continuous_Service_Date>
                  <xhr:First_Day_of_Work>2025-10-01</xhr:First_Day_of_Work>
                  <xhr:Seniority_Date>2025-10-01</xhr:Seniority_Date>
                  <xhr:Benefits_Service_Date/>
                  <xhr:Company_Service_Date>2025-10-01</xhr:Company_Service_Date>
                  <xhr:Is_Retired>false</xhr:Is_Retired>
                  <xhr:Is_Terminated>false</xhr:Is_Terminated>
                  <xhr:Is_Rehire>false</xhr:Is_Rehire>
                  <xhr:Days_Unemployed>0</xhr:Days_Unemployed>
                  <!-- Contract End — only present for contingent workers -->
                  <xhr:Contract_End_Date>2026-09-30</xhr:Contract_End_Date>
                  <xhr:Contract_Renewable>true</xhr:Contract_Renewable>
                </xhr:Employment_Status>

              </xhr:Job_Data>
            </xhr:Employment_Data>

          </xhr:Employee_Data>
        </xhr:Employee>

      </xhr:Response_Data>
    </xhr:GetEmployees_Response>
  </soap:Body>
</soap:Envelope>"}
\ No newline at end of file
diff --git a/src/pages/tools/xpath-evaluator.tsx b/src/pages/tools/xpath-evaluator.tsx
index 9a6e09698b7ce..59ff9ecb0dcb2 100644
--- a/src/pages/tools/xpath-evaluator.tsx
+++ b/src/pages/tools/xpath-evaluator.tsx
@@ -35,8 +35,8 @@ const documentationLinks: Record<
   
   const XPathEvaluator: React.FC = () => {
   const [result, setResult] = useState<string>(JSON.stringify([], null, 4));
-  const [query, setQuery] = useState<string>('wd:Worker_Data/wd:Personal_Data/wd:Name_Data/wd:Legal_Name_Data/wd:Name_Detail_Data/wd:Last_Name | wd:Applicant_Data/wd:Personal_Data/wd:Name_Data/wd:Legal_Name_Data/wd:Name_Detail_Data/wd:Last_Name');
-  const [root, setRoot] = useState<string>('//wd:Response_Data/wd:Worker');
+  const [query, setQuery] = useState<string>('xhr:Employee_Data/xhr:Personal_Data/xhr:Name_Data/xhr:Legal_Name/xhr:Name_Detail/xhr:Last_Name');
+  const [root, setRoot] = useState<string>('//xhr:Response_Data/xhr:Employee');
   const [queryParseError, setQueryParseError] = useState<string>('');
   const [fontSize, setFontSize] = useState<string>('16');
   const [inputXml, setInputXml] = useState<string>(sampleXml);