/* ========================================================= Enterprise Data Access — functional integration console. Guided journey: 1. Where does your data live? (platform picker) 2. Pick your delivery pattern (recommended + alternative) 3. Connect (setup wizard) Webhooks and bucket exports are fully self-serve; CDC, direct BI access and Iceberg shares create provisioning requests. Every connection is mirrored into the AI knowledge base (embeddings) unless the toggle is off. The marketing "trust package" lives on the landing page (marketing.jsx) — this page stays focused on doing. Backend: /api/v1/data-access/connections (api.dataAccess.*). Signing secrets are shown exactly once, on create / rotate. ========================================================= */ const ED_PATTERNS = [ { id: "webhooks", letter: "A", name: "Signed webhooks", latency: "Real-time", direction: "Push", icon: "zap", selfServe: true, blurb: "Domain events — call.completed, ticket.created, billing — delivered to your HTTPS endpoint or straight onto your EventBridge bus.", stages: [ { title: "Mikaka outbox", sub: "per-tenant events only", icon: "inbox" }, { title: "HMAC-SHA256 signed", sub: "id · timestamp · payload", icon: "shield" }, { title: "Your endpoint / bus", sub: "you verify our signature", icon: "globe" }, ], controls: [ "Standard Webhooks spec: webhook-id, webhook-timestamp, webhook-signature headers", "5-minute timestamp window rejects replays; webhook-id doubles as your idempotency key", "Per-tenant signing secret, encrypted at rest, shown once and rotatable anytime", "Cross-account EventBridge delivery with IAM role + External ID for AWS-native stacks", ], bestFor: ["Any platform", "Fastest to ship", "Event-driven systems"], confidence: "Events arrive signed and timestamped at your endpoint. You verify our signature — nothing is pullable from our side.", }, { id: "exports", letter: "B", name: "Files to your bucket", latency: "Batch", direction: "Push", icon: "download", selfServe: true, blurb: "Scheduled Parquet / Iceberg drops of your tenant slice into an S3, GCS, ADLS or Huawei OBS bucket that you own and you key.", stages: [ { title: "Tenant-filtered export", sub: "WHERE tenant_id = yours", icon: "filter" }, { title: "Cross-account role", sub: "External ID · your KMS CMK", icon: "shield" }, { title: "Your bucket", sub: "Snowpipe · DBMS_CLOUD · COPY", icon: "layers" }, ], controls: [ "Data lands in your bucket, encrypted with your KMS customer-managed key (BYOK)", "Cross-account IAM role gated by an External ID — no shared credentials, no confused deputy", "Open formats (Parquet / Iceberg) ingest natively into Snowflake, Redshift, Oracle, BigQuery, Databricks, GaussDB DWS", "Revoke your key and the pipeline is cut off instantly — the kill switch is in your hands", ], bestFor: ["Snowflake", "Redshift", "Oracle ADB", "BigQuery", "Databricks", "Huawei GaussDB"], confidence: "Your bucket, your KMS key, your S3 access logs. Revoke the key and we are cut off instantly.", }, { id: "cdc", letter: "C", name: "Streaming CDC", latency: "Near real-time", direction: "Push", icon: "refresh", selfServe: false, blurb: "A live mirror: inserts, updates and deletes stream from a row-filtered Postgres publication into your warehouse.", stages: [ { title: "Row-filtered publication", sub: "WHERE tenant_id = yours, in WAL", icon: "filter" }, { title: "CDC transport", sub: "Fivetran · Airbyte · DMS · Debezium", icon: "refresh" }, { title: "Your warehouse", sub: "a continuously updated copy", icon: "chart" }, ], controls: [ "Postgres 17 row-filtered publications — only your rows ever enter the replication slot", "Server-side isolation that does not depend on application RLS", "REPLICA IDENTITY configured so update/delete filters hold", "Dedicated slots reserved for enterprise accounts and monitored for lag", ], bestFor: ["Live mirrors", "BigQuery", "Large enterprise tenants"], confidence: "A continuously updated copy of only your rows, filtered at the source — not at the destination.", }, { id: "direct", letter: "D", name: "Direct BI access", latency: "Live", direction: "Pull", icon: "chart", selfServe: false, blurb: "Point Tableau, Power BI or Looker at a read replica over JDBC/ODBC with a login that can only ever see your tenant.", stages: [ { title: "Read replica", sub: "never the primary", icon: "layers" }, { title: "PrivateLink · TLS verify-full", sub: "per-tenant read-only role", icon: "shield" }, { title: "Your BI tools", sub: "Tableau · Power BI · Looker", icon: "chart" }, ], controls: [ "Per-tenant read-only database role — tenant bound at the connection, enforced by row-level policy", "Served from a read replica so your analytics can never touch production", "PrivateLink / VPC peering or strict IP allowlist; TLS verify-full end to end", "Short-lived, Vault-issued credentials on a rotation schedule", ], bestFor: ["Tableau", "Power BI", "Looker", "Ad-hoc SQL"], confidence: "Your existing BI stack over a private link, with a read-only login scoped to your tenant and nothing else.", }, { id: "iceberg", letter: "E", name: "Zero-copy sharing", latency: "Live + batch", direction: "Shared", icon: "sparkles", selfServe: false, blurb: "Your slice written once as Apache Iceberg; Snowflake, Oracle, Databricks and Trino read it in place. No ETL, no duplication.", stages: [ { title: "Iceberg tables", sub: "written once, open format", icon: "layers" }, { title: "REST catalog", sub: "governed, open protocol", icon: "book" }, { title: "Every engine", sub: "Snowflake · Oracle · Trino · Spark", icon: "globe" }, ], controls: [ "Open table format — no vendor lock-in, no proprietary export pipeline to trust", "Reads are governed through the catalog; grants are auditable and revocable", "One copy of the data: nothing drifts, nothing is duplicated across vendors", "Pairs with warehouse-native secure data sharing as a zero-movement alternative", ], bestFor: ["Snowflake", "Oracle ADB", "Databricks", "Lakehouse teams"], confidence: "You read the data in place through an open catalog — there is no pipeline to compromise.", }, ]; const ED_PLATFORMS = [ { id: "aws", name: "AWS", sub: "Redshift · S3 · Athena", rec: "exports", alt: "webhooks" }, { id: "oracle", name: "Oracle", sub: "Autonomous DB · Exadata", rec: "exports", alt: "iceberg" }, { id: "snowflake", name: "Snowflake", sub: "Secure sharing · Snowpipe", rec: "iceberg", alt: "exports" }, { id: "gcp", name: "Google Cloud", sub: "BigQuery", rec: "cdc", alt: "exports" }, { id: "azure", name: "Azure", sub: "Synapse · Fabric", rec: "exports", alt: "webhooks" }, { id: "huawei", name: "Huawei Cloud", sub: "GaussDB DWS · OBS · DLI", rec: "exports", alt: "webhooks" }, { id: "bi", name: "BI tools", sub: "Tableau · Power BI · Looker",rec: "direct", alt: "iceberg" }, { id: "any", name: "Not sure yet", sub: "Start universal", rec: "webhooks",alt: "exports" }, ]; const ED_EVENTS = [ ["call.completed", "Call completed"], ["call.started", "Call started"], ["call.missed", "Call missed"], ["ticket.created", "Ticket created"], ["appointment.booked", "Appointment booked"], ["billing.invoice", "Billing invoice"], ]; const ED_STATUS_CHIP = { active: live, pending: awaiting validation, provisioning: provisioning, error: error, disabled: disabled, }; const edCopy = async (text, toast, label = "Copied to clipboard") => { try { await navigator.clipboard.writeText(text); toast({ title: "Copied", body: label }); } catch { toast({ title: "Copy failed", body: "Select and copy the value manually.", kind: "danger" }); } }; const ED_VERIFY_SNIPPET = `// Verify a Mikaka webhook (Node.js) const crypto = require("crypto"); function verify(secret, headers, rawBody) { const id = headers["webhook-id"], ts = headers["webhook-timestamp"]; if (Math.abs(Date.now() / 1000 - Number(ts)) > 300) return false; // replay window const key = Buffer.from(secret.replace("whsec_", ""), "base64"); const expected = crypto.createHmac("sha256", key) .update(\`\${id}.\${ts}.\${rawBody}\`).digest("base64"); return headers["webhook-signature"] .split(" ").some(s => crypto.timingSafeEqual( Buffer.from(s.replace("v1,", "")), Buffer.from(expected))); }`; const edTrustPolicy = (externalId) => JSON.stringify({ Version: "2012-10-17", Statement: [{ Effect: "Allow", Principal: { AWS: "arn:aws:iam::MIKAKA_DELIVERY_ACCOUNT:role/mikaka-export-writer" }, Action: "sts:AssumeRole", Condition: { StringEquals: { "sts:ExternalId": externalId } }, }], }, null, 2); // Huawei Cloud IAM custom policy to attach to the delegation agency (OBS write, // scoped to the export bucket). Policy "Version 1.1" is Huawei's policy syntax. const edObsAgencyPolicy = (bucket, externalId) => JSON.stringify({ Version: "1.1", Statement: [{ Effect: "Allow", Action: ["obs:object:PutObject", "obs:object:GetObject", "obs:bucket:ListBucket", "obs:bucket:HeadBucket"], Resource: [ `OBS:*:*:bucket:${bucket || "YOUR_BUCKET"}`, `OBS:*:*:object:${bucket || "YOUR_BUCKET"}/mikaka/${externalId}/*`, ], }], }, null, 2); /* ---------------- small form primitives ---------------- */ const ED_Field = ({ label, hint, children }) => ( ); const ED_Seg = ({ options, value, onChange }) => (
{options.map(([v, l]) => ( ))}
); const ED_EmbedToggle = ({ value, onChange }) => (
onChange(!value)} onKeyDown={(e) => { if (e.key === "Enter" || e.key === " ") { e.preventDefault(); onChange(!value); } }} >
{value && }
Add to AI knowledge base (embeddings)
Mikaka chunks and embeds this connection so your AI Voice Employee knows where your data flows and can answer questions about it.
); const ED_Code = ({ text, toast, label }) => ( 
{text}
); /* ---------------- setup wizard ---------------- */ const ED_SetupWizard = ({ pattern, platform, onClose, onCreated }) => { const toast = useToast(); const [busy, setBusy] = useState(false); const [created, setCreated] = useState(null); // response after create (step 2) const [testResult, setTestResult] = useState(null); const [form, setForm] = useState({ name: `${pattern.name} — ${platform?.name && platform.id !== "any" ? platform.name : "Main"}`, embed: true, endpoint_url: "", events: ["call.completed"], provider: platform?.id === "huawei" ? "obs" : platform?.id === "gcp" ? "gcs" : platform?.id === "azure" ? "azure" : "s3", bucket: "", region: "", role_arn: "", agency: "", domain_id: "", format: "parquet", schedule: "daily", destination: "", transport: "fivetran", tables: "", bi_tool: "", network: "privatelink", cidrs: "", catalog_consumer: "", engine: "", notes: "", }); const set = (k, v) => setForm(f => ({ ...f, [k]: v })); const buildConfig = () => { if (pattern.id === "webhooks") return { endpoint_url: form.endpoint_url.trim(), events: form.events }; if (pattern.id === "exports") { const cfg = { provider: form.provider, bucket: form.bucket.trim(), region: form.region.trim(), format: form.format, schedule: form.schedule, }; if (form.provider === "s3") cfg.role_arn = form.role_arn.trim(); if (form.provider === "obs") { cfg.agency = form.agency.trim(); cfg.domain_id = form.domain_id.trim(); } return cfg; } if (pattern.id === "cdc") return { destination: form.destination.trim(), transport: form.transport, tables: form.tables.split(",").map(s => s.trim()).filter(Boolean), notes: form.notes.trim(), }; if (pattern.id === "direct") return { bi_tool: form.bi_tool.trim(), network: form.network, cidrs: form.cidrs.split(",").map(s => s.trim()).filter(Boolean), notes: form.notes.trim(), }; return { catalog_consumer: form.catalog_consumer.trim(), engine: form.engine.trim(), notes: form.notes.trim() }; }; const submit = async () => { if (!form.name.trim()) { toast({ title: "Name required", kind: "danger" }); return; } if (pattern.id === "webhooks" && !form.endpoint_url.trim()) { toast({ title: "Endpoint URL required", kind: "danger" }); return; } if (pattern.id === "exports" && !form.bucket.trim()) { toast({ title: "Bucket required", kind: "danger" }); return; } setBusy(true); try { const row = await api.dataAccess.create({ pattern: pattern.id, platform: platform?.id || "any", name: form.name.trim(), config: buildConfig(), embed_enabled: form.embed, }); setCreated(row); onCreated && onCreated(row); toast({ title: "Connection created", body: form.embed ? "Embedding into your AI knowledge base has been queued." : row.name }); } catch (err) { toast({ title: "Could not create connection", body: err?.message || "Try again.", kind: "danger" }); } finally { setBusy(false); } }; const sendTest = async () => { if (!created?.id) return; setBusy(true); setTestResult(null); try { const res = await api.dataAccess.test(created.id); setTestResult(res); toast(res.ok ? { title: "Test delivered", body: `Endpoint answered HTTP ${res.status_code}.` } : { title: "Test failed", body: res.detail, kind: "danger" }); } catch (err) { toast({ title: "Test failed", body: err?.message, kind: "danger" }); } finally { setBusy(false); } }; const toggleEvent = (ev) => { set("events", form.events.includes(ev) ? form.events.filter(e => e !== ev) : [...form.events, ev]); }; const formBody = ( <> set("name", e.target.value)} maxLength={120}/> {pattern.id === "webhooks" && ( <> set("endpoint_url", e.target.value)}/>
{ED_EVENTS.map(([ev, label]) => { const on = form.events.includes(ev); return ( ); })}
)} {pattern.id === "exports" && ( <> set("provider", v)} options={[["s3", "AWS S3"], ["gcs", "Google GCS"], ["azure", "Azure ADLS"], ["obs", "Huawei OBS"]]}/>
set("bucket", e.target.value)}/> set("region", e.target.value)}/>
{form.provider === "s3" && ( set("role_arn", e.target.value)}/> )} {form.provider === "obs" && (
set("agency", e.target.value)}/> set("domain_id", e.target.value)}/>
)}
set("format", v)} options={[["parquet", "Parquet"], ["iceberg", "Iceberg"], ["csv", "CSV"]]}/> set("schedule", v)} options={[["hourly", "Hourly"], ["daily", "Daily"], ["weekly", "Weekly"]]}/>
)} {pattern.id === "cdc" && ( <> set("destination", e.target.value)}/> set("transport", v)} options={[["fivetran", "Fivetran"], ["airbyte", "Airbyte"], ["dms", "AWS DMS"], ["debezium", "Debezium"]]}/> set("tables", e.target.value)}/> )} {pattern.id === "direct" && ( <> set("bi_tool", e.target.value)}/> set("network", v)} options={[["privatelink", "PrivateLink / peering"], ["ip_allowlist", "IP allowlist"]]}/> {form.network === "ip_allowlist" && ( set("cidrs", e.target.value)}/> )} )} {pattern.id === "iceberg" && ( <> set("catalog_consumer", e.target.value)}/> set("engine", e.target.value)}/> )} {!pattern.selfServe && ( set("notes", e.target.value)}/> )} set("embed", v)}/> ); const successBody = created && ( <>
{created.name}
{ED_STATUS_CHIP[created.status] || {created.status}} {created.embed_enabled && embedding queued}
{pattern.id === "webhooks" && created.signing_secret && ( <>
Signing secret — shown only once
Store it in your secret manager now. You can rotate it later, but this value is never displayed again.
Verify our signature
{testResult && (testResult.ok ? delivered · HTTP {testResult.status_code} : {testResult.detail})}
)} {pattern.id === "exports" && created.external_id && ( <>
Your External ID
{(created.config?.provider === "obs") ? <>Exports are written under the prefix mikaka/{created.external_id}/ in your bucket. Scope your agency's policy to that prefix so only your tenant's slice is ever writable. : <>Add this condition to your role's trust policy. It prevents anyone but your tenant from invoking the delivery role (confused-deputy protection).}
{(created.config?.provider === "obs") ? ( <>
Set up the delegation agency in Huawei IAM
In IAM → Agencies → Create Agency, choose agency type Cloud account, name it {created.config?.agency || "mikaka-export-writer"}, set the delegated account to Mikaka Delivery (we confirm our account name during validation), then attach this custom policy:
) : ( <>
Trust policy for your role
)}
Status stays awaiting validation until our delivery service confirms it can {created.config?.provider === "obs" ? "assume the agency" : "assume the role"} and write a test object. You'll see it flip to live here.
)} {!pattern.selfServe && (
This pattern needs cloud-side provisioning (replication slots, network paths, or catalog grants), so it starts in provisioning. Our solutions team picks it up with your details and confirms the cutover window with your security team. Track its status in Your data connections on this page.
)} ); return ( Done ) : ( <> )} > {created ? successBody : formBody} ); }; /* ---------------- connection list ---------------- */ const ED_EmbedChip = ({ c }) => { if (!c.embed_enabled) return AI embeddings off; if (c.embed_status === "embedded") return in AI knowledge; if (c.embed_status === "error") return embed failed; return embedding…; }; const ED_ConnectionCard = ({ c, onAction, busy }) => { const pattern = ED_PATTERNS.find(p => p.id === c.pattern) || ED_PATTERNS[0]; const cfg = c.config || {}; const target = c.pattern === "webhooks" ? cfg.endpoint_url : c.pattern === "exports" ? `${(cfg.provider || "s3").toUpperCase()} · ${cfg.bucket || ""}` : c.pattern === "cdc" ? cfg.destination : c.pattern === "direct" ? cfg.bi_tool : cfg.catalog_consumer; return (
{pattern.letter}
{c.name}
{pattern.name}{target ? ` → ${target}` : ""}
{ED_STATUS_CHIP[c.status] || {c.status}}
{(c.last_delivery_at || c.last_error) && (
{c.last_error ? `Last delivery failed: ${c.last_error}` : `Last delivery ${new Date(c.last_delivery_at).toLocaleString()} · ${c.last_delivery_status}`}
)}
{c.pattern === "webhooks" && c.status === "active" && ( )} {c.pattern === "webhooks" && ( )}
); }; /* ---------------- journey stepper ---------------- */ const ED_Stepper = ({ current }) => { const steps = ["Choose your platform", "Pick the delivery pattern", "Connect"]; return (
{steps.map((label, i) => { const n = i + 1; const done = current > n; const active = current === n; return ( {i > 0 &&
i ? "var(--mk-orange)" : "var(--border)", margin: "0 8px", alignSelf: "center", transition: "background .3s" }}/>}
{done ? : n} {label}
); })}
); }; /* ---------------- page ---------------- */ const EnterpriseDataAccess = () => { const toast = useToast(); const store = MK_USE(); const [platformId, setPlatformId] = useState(null); // step 1 — nothing chosen yet const [patternId, setPatternId] = useState(null); // step 2 — set when platform picked const [connections, setConnections] = useState([]); const [listState, setListState] = useState("loading"); // loading | ready | unauth | unavailable | error const [listError, setListError] = useState(""); const [busyId, setBusyId] = useState(null); const [wizard, setWizard] = useState(null); // pattern object when open (step 3) const [rotated, setRotated] = useState(null); // {name, secret} after rotation const [confirmDelete, setConfirmDelete] = useState(null); const stepTwoRef = useRef(null); const platform = ED_PLATFORMS.find(p => p.id === platformId) || null; const pattern = ED_PATTERNS.find(p => p.id === patternId) || null; const journeyStep = !platform ? 1 : 2; const loadConnections = async (quiet = true) => { try { const rows = await api.dataAccess.list(); setConnections(Array.isArray(rows) ? rows : []); setListState("ready"); if (!quiet) toast({ title: "Connections refreshed" }); } catch (err) { if (err?.status === 401) setListState("unauth"); else if (err?.status === 503) { setListState("unavailable"); setListError(err?.message || ""); } else { setListState("error"); setListError(err?.message || "Could not load connections."); } } }; useEffect(() => { loadConnections(); }, []); const pickPlatform = (p) => { setPlatformId(p.id); setPatternId(p.rec); // Bring step 2 into view once it renders. setTimeout(() => stepTwoRef.current?.scrollIntoView({ behavior: "smooth", block: "start" }), 80); }; const onAction = async (action, c) => { if (action === "delete") { setConfirmDelete(c); return; } setBusyId(c.id); try { if (action === "test") { const res = await api.dataAccess.test(c.id); toast(res.ok ? { title: "Test delivered", body: `Endpoint answered HTTP ${res.status_code}.` } : { title: "Test failed", body: res.detail, kind: "danger" }); } else if (action === "rotate") { const row = await api.dataAccess.rotateSecret(c.id); setRotated({ name: c.name, secret: row.signing_secret }); } else if (action === "enable" || action === "disable") { await api.dataAccess.update(c.id, { enabled: action === "enable" }); toast({ title: action === "enable" ? "Connection enabled" : "Connection disabled", body: c.name }); } await loadConnections(); } catch (err) { toast({ title: "Action failed", body: err?.message, kind: "danger" }); } finally { setBusyId(null); } }; const doDelete = async () => { const c = confirmDelete; setConfirmDelete(null); setBusyId(c.id); try { await api.dataAccess.remove(c.id); toast({ title: "Connection deleted", body: `${c.name} and its knowledge-base entry were removed.` }); await loadConnections(); } catch (err) { toast({ title: "Delete failed", body: err?.message, kind: "danger" }); } finally { setBusyId(null); } }; const hasConnections = listState === "ready" && connections.length > 0; return (

Enterprise Data Access

Your data, in your cloud, under your keys. Three steps from "where does it live" to a live, governed connection.

{hasConnections && pattern && ( )}
{/* Existing connections come first for returning users */} {listState === "unavailable" && (
Data access isn't enabled on this environment yet. {listError}
)} {listState === "unauth" && (
Sign in to your workspace to create and manage live data connections. The setup guide below stays browsable.
)} {listState === "error" && (
{listError}
)} {hasConnections && (
{connections.map(c => ( ))}
)} {/* Guided journey */}
{/* Step 1 — platform */}
Step 1 · Where does your data live?
{ED_PLATFORMS.map(p => (
pickPlatform(p)} onKeyDown={(e) => { if (e.key === "Enter" || e.key === " ") { e.preventDefault(); pickPlatform(p); } }} >
{p.name}
{p.sub}
))}
{/* Step 2 — pattern (appears after step 1) */} {platform && (
Step 2 · Pick the delivery pattern
{platform.id !== "any" ? <>For {platform.name} we recommend {ED_PATTERNS.find(x => x.id === platform.rec)?.name}; {ED_PATTERNS.find(x => x.id === platform.alt)?.name} is the usual alternative. : <>Signed webhooks are the universal starting point — every platform can receive them.}
{ED_PATTERNS.map(p => { const isRec = platform.rec === p.id; const isAlt = platform.alt === p.id; return (
setPatternId(p.id)} onKeyDown={(e) => { if (e.key === "Enter" || e.key === " ") { e.preventDefault(); setPatternId(p.id); } }} > {p.letter} {p.name} {isRec && platform.id !== "any" && best fit} {isAlt && platform.id !== "any" && alt}
); })}
{pattern && ( setWizard(pattern)} /> )}
)} {!platform && (
Pick a platform above to see your recommended delivery pattern.
)}
{/* Quiet trust footer — the full story lives on the landing page */} {/* Overlays */} {wizard && ( setWizard(null)} onCreated={() => loadConnections()} /> )} {rotated && ( setRotated(null)} size="md" title="New signing secret" sub={`${rotated.name} — shown only once`} footer={}>
Update your secret manager now; the previous secret stops verifying as soon as you deploy this one.
)} {confirmDelete && ( setConfirmDelete(null)} size="sm" title="Delete connection?" sub={confirmDelete.name} footer={( <> )}>
Delivery stops immediately and the connection's entry is removed from your AI knowledge base. This cannot be undone.
)}
); }; /* ---------------- explanatory pieces (pipeline + detail) ---------------- */ const ED_FlowArrow = ({ vertical }) => ( ); const ED_StageCard = ({ stage, accent }) => (
{stage.title}
{stage.sub}
); const ED_Pipeline = ({ pattern }) => { const [narrow, setNarrow] = useState(() => window.innerWidth < 760); useEffect(() => { const onResize = () => setNarrow(window.innerWidth < 760); window.addEventListener("resize", onResize); return () => window.removeEventListener("resize", onResize); }, []); return (
{pattern.stages.map((stage, i) => ( {i > 0 && } ))}
); }; const ED_PatternDetail = ({ pattern, recommendedFor, onSetup }) => (
{pattern.letter}

Pattern {pattern.letter} — {pattern.name}

{recommendedFor && recommended for {recommendedFor}} {pattern.selfServe ? self-serve : provisioned}
{pattern.latency} {pattern.direction} {pattern.bestFor.map(b => {b})}

{pattern.blurb}

How it stays yours
{pattern.controls.map(c => (
{c}
))}
“{pattern.confidence}”
); Object.assign(window, { EnterpriseDataAccess });