@genesislcap/foundation-ui 14.398.0 → 14.400.0

package/dist/esm/ai-criteria-search/validation/operator-map.js

@@ -0,0 +1,97 @@
+/**
+ * Maps IR operators to Groovy criteria using foundation-criteria.
+ *
+ * @public
+ */
+import { CriteriaBuilder, ExpressionBuilder, Join, Serialisers, } from '@genesislcap/foundation-criteria';
+const OPERATOR_TO_SERIALISER = {
+    contains: Serialisers.containsIgnoreCase,
+    equals: Serialisers.EQ,
+    startsWith: Serialisers.startsWith,
+    endsWith: Serialisers.endsWith,
+    greaterThan: Serialisers.GT,
+    lessThan: Serialisers.LT,
+    greaterThanOrEqual: Serialisers.GE,
+    lessThanOrEqual: Serialisers.LE,
+    notEqual: Serialisers.NE,
+    dateIsToday: Serialisers.dateIsToday,
+    dateIsAfter: Serialisers.dateIsGreaterEqual,
+    dateIsGreaterEqual: Serialisers.dateIsGreaterEqual,
+    dateIsBefore: Serialisers.dateIsLessEqual,
+    dateIsLessEqual: Serialisers.dateIsLessEqual,
+    dateIsEqual: Serialisers.dateIsEqual,
+    dateTimeIsAfter: Serialisers.dateTimeIsGreaterEqual,
+    dateTimeIsGreaterEqual: Serialisers.dateTimeIsGreaterEqual,
+    dateTimeIsBefore: Serialisers.dateTimeIsLessEqual,
+    dateTimeIsLessEqual: Serialisers.dateTimeIsLessEqual,
+};
+function clauseToExpression(clause) {
+    var _a, _b;
+    const serialiser = (_a = OPERATOR_TO_SERIALISER[clause.operator]) !== null && _a !== void 0 ? _a : Serialisers.containsIgnoreCase;
+    return new ExpressionBuilder()
+        .withField(clause.field)
+        .withValue((_b = clause.value) !== null && _b !== void 0 ? _b : null)
+        .withSerialiser(serialiser)
+        .withGroup('default')
+        .build();
+}
+function buildGroupExpression(expressions, groupJoin) {
+    if (expressions.length === 1)
+        return expressions[0];
+    return expressions.reduce((acc, expr, i) => (i === 0 ? [expr] : [...acc, groupJoin, expr]), []);
+}
+/**
+ * Converts validated CriteriaGroup[] to a Groovy criteria string using CriteriaBuilder.
+ * Groups are AND-ed at top level. Within each group, clauses use group.logic (and/or).
+ * If group.negated is true, the group's combined expression is wrapped in NOT.
+ */
+export function groupsToCriteria(groups) {
+    var _a;
+    const builder = new CriteriaBuilder();
+    let hasAny = false;
+    for (const group of groups) {
+        if (!((_a = group.clauses) === null || _a === void 0 ? void 0 : _a.length))
+            continue;
+        const expressions = group.clauses.map(clauseToExpression);
+        const groupJoin = group.logic === 'or' ? Join.Or() : Join.And();
+        const compound = buildGroupExpression(expressions, groupJoin);
+        const opts = expressions.length > 1 ? { join: groupJoin } : {};
+        if (group.negated) {
+            builder.And([Join.Not(), compound]);
+        }
+        else {
+            builder.And(expressions.length === 1 ? expressions[0] : expressions, opts);
+        }
+        hasAny = true;
+    }
+    return hasAny ? builder.build() : '';
+}
+export const STRING_OPERATORS = [
+    'contains',
+    'equals',
+    'startsWith',
+    'endsWith',
+    'notEqual',
+];
+export const NUMERIC_OPERATORS = [
+    'equals',
+    'greaterThan',
+    'lessThan',
+    'greaterThanOrEqual',
+    'lessThanOrEqual',
+    'notEqual',
+];
+export const DATE_OPERATORS = [
+    'dateIsToday',
+    'dateIsAfter',
+    'dateIsBefore',
+    'dateIsEqual',
+    'dateIsGreaterEqual',
+    'dateIsLessEqual',
+];
+export const DATETIME_OPERATORS = [
+    'dateTimeIsAfter',
+    'dateTimeIsBefore',
+    'dateTimeIsGreaterEqual',
+    'dateTimeIsLessEqual',
+];

package/dist/esm/ai-criteria-search/validation/schema-validator.js

@@ -0,0 +1,150 @@
+/**
+ * Schema-first validation for AI-generated criteria clauses.
+ * Never auto-corrects; surfaces structured errors.
+ *
+ * @public
+ */
+import { DATE_OPERATORS, DATETIME_OPERATORS, NUMERIC_OPERATORS, STRING_OPERATORS, } from './operator-map';
+/** Genesis server date types - exact match to avoid false positives (e.g. STATUS containing INT) */
+const DATE_TYPE_SET = new Set(['DATE', 'LOCALDATE']);
+/** Genesis server datetime types */
+const DATETIME_TYPE_SET = new Set(['DATETIME', 'NANO_TIMESTAMP', 'LOCALDATETIME', 'TIMESTAMP']);
+/** Genesis server numeric types */
+const NUMERIC_TYPE_SET = new Set([
+    'INT',
+    'INTEGER',
+    'LONG',
+    'SHORT',
+    'DOUBLE',
+    'BIGDECIMAL',
+    'DECIMAL',
+]);
+/** Normalize type by stripping parameters e.g. STRING(256) -> STRING, BIGDECIMAL(10,3) -> BIGDECIMAL */
+function normalizeFieldType(fieldType) {
+    return (fieldType || '').toUpperCase().trim().split('(')[0].trim();
+}
+function getOperatorsForFieldType(fieldType) {
+    const normalized = normalizeFieldType(fieldType);
+    if (DATE_TYPE_SET.has(normalized))
+        return DATE_OPERATORS;
+    if (DATETIME_TYPE_SET.has(normalized))
+        return DATETIME_OPERATORS;
+    if (NUMERIC_TYPE_SET.has(normalized))
+        return NUMERIC_OPERATORS;
+    return STRING_OPERATORS;
+}
+function isNumericFieldType(fieldType) {
+    return NUMERIC_TYPE_SET.has(normalizeFieldType(fieldType));
+}
+function isValidDateValue(value) {
+    if (value === null || value === undefined)
+        return false;
+    if (typeof value === 'number')
+        return !Number.isNaN(value) && value > 0;
+    if (typeof value === 'string') {
+        return (/^\d{8}$/.test(value) ||
+            /^\d{4}-\d{2}-\d{2}$/.test(value) ||
+            /^\d{8}-\d{2}:\d{2}(:\d{2})?$/.test(value));
+    }
+    return false;
+}
+function isValidNumericValue(value) {
+    if (value === null || value === undefined)
+        return false;
+    if (typeof value === 'number')
+        return !Number.isNaN(value);
+    if (typeof value === 'string')
+        return !Number.isNaN(Number(value));
+    return false;
+}
+export function validateClauses(clauses, fieldMetadata) {
+    const valid = [];
+    const invalid = [];
+    const fieldMap = new Map();
+    if (Array.isArray(fieldMetadata) && fieldMetadata.length > 0) {
+        const first = fieldMetadata[0];
+        if (typeof first === 'string') {
+            fieldMetadata.forEach((name) => fieldMap.set(name, undefined));
+        }
+        else {
+            fieldMetadata.forEach((m) => fieldMap.set(m.NAME, m));
+        }
+    }
+    for (const clause of clauses) {
+        const { field, operator, value } = clause;
+        if (!field || typeof field !== 'string') {
+            invalid.push({ field: String(field), message: 'Field name is required' });
+            continue;
+        }
+        const meta = fieldMap.get(field);
+        const fieldType = meta && 'TYPE' in meta ? meta.TYPE : 'STRING';
+        const allowedOperators = getOperatorsForFieldType(fieldType);
+        if (!allowedOperators.includes(operator)) {
+            invalid.push({
+                field,
+                operator,
+                value,
+                message: `Operator '${operator}' is not allowed for field type ${fieldType}`,
+            });
+            continue;
+        }
+        if (DATE_OPERATORS.includes(operator) || DATETIME_OPERATORS.includes(operator)) {
+            if (operator !== 'dateIsToday' && !isValidDateValue(value)) {
+                invalid.push({
+                    field,
+                    operator,
+                    value,
+                    message: 'Invalid date/datetime value; use yyyyMMdd, yyyy-MM-dd, or epoch',
+                });
+                continue;
+            }
+        }
+        if (isNumericFieldType(fieldType) &&
+            NUMERIC_OPERATORS.includes(operator) &&
+            !isValidNumericValue(value)) {
+            invalid.push({
+                field,
+                operator,
+                value,
+                message: 'Invalid numeric value',
+            });
+            continue;
+        }
+        if (fieldMap.size > 0 && !fieldMap.has(field)) {
+            invalid.push({
+                field,
+                operator,
+                value,
+                message: `Unknown field '${field}'`,
+            });
+            continue;
+        }
+        valid.push(clause);
+    }
+    return { valid, invalid };
+}
+/**
+ * Validates groups of criteria clauses. Each group's clauses are validated
+ * using the same per-clause logic as validateClauses.
+ */
+export function validateGroups(groups, fieldMetadata) {
+    var _a;
+    const valid = [];
+    const invalid = [];
+    for (const group of groups) {
+        if (!(group === null || group === void 0 ? void 0 : group.clauses) || !Array.isArray(group.clauses)) {
+            invalid.push({ field: '', message: 'Group must have a clauses array' });
+            continue;
+        }
+        const { valid: validClauses, invalid: invalidClauses } = validateClauses(group.clauses, fieldMetadata);
+        invalid.push(...invalidClauses);
+        if (validClauses.length > 0) {
+            valid.push({
+                logic: (_a = group.logic) !== null && _a !== void 0 ? _a : 'and',
+                negated: group.negated,
+                clauses: validClauses,
+            });
+        }
+    }
+    return { valid, invalid };
+}

package/dist/esm/ai-criteria-search/validation-error-notification.js

@@ -0,0 +1,34 @@
+import { showNotification } from '@genesislcap/foundation-notifications';
+const TOAST_CLOSE_TIMEOUT_MS = 4000;
+/**
+ * Formats validation errors into a user-friendly message.
+ */
+export function formatValidationErrors(errors) {
+    if (errors.length === 0)
+        return '';
+    if (errors.length === 1)
+        return errors[0].message;
+    return errors.map((e) => e.message).join('; ');
+}
+/**
+ * Shows a criteria error as a toast notification.
+ *
+ * @param title - Notification title (e.g. "Criteria validation error")
+ * @param body - Error message to display
+ * @param tagName - Design system prefix (e.g. "rapid", "foundation")
+ */
+export function showCriteriaError(title, body, tagName) {
+    if (!(body === null || body === void 0 ? void 0 : body.trim()))
+        return;
+    showNotification({
+        title,
+        body,
+        config: {
+            toast: {
+                autoClose: true,
+                closeTimeout: TOAST_CLOSE_TIMEOUT_MS,
+                type: 'error',
+            },
+        },
+    }, tagName);
+}

package/dist/esm/ai-indicator/ai-indicator.js

@@ -0,0 +1,190 @@
+import { __awaiter, __decorate } from "tslib";
+import { AIProvider } from '@genesislcap/foundation-ai';
+import { observable, volatile } from '@microsoft/fast-element';
+import { FoundationElement } from '@microsoft/fast-foundation';
+import { wasClickOutsideElement } from '../utils';
+import { foundationAiIndicatorStyles as styles } from './ai-indicator.styles';
+import { foundationAiIndicatorTemplate as template } from './ai-indicator.template';
+const POLL_INTERVAL_MS = 2500;
+/**
+ * @tagname %%prefix%%-ai-indicator
+ */
+export class AiIndicator extends FoundationElement {
+    constructor() {
+        super(...arguments);
+        this.status = null;
+        this.open = false;
+        this.state = 'none';
+        this.isInstalling = false;
+        this.pollTimer = null;
+        this.clickOutside = (e) => this.handleClickOutside(e);
+    }
+    get chromeStatusLabel() {
+        var _a, _b;
+        if (((_a = this.status) === null || _a === void 0 ? void 0 : _a.provider) !== 'chrome')
+            return null;
+        const a = (_b = this.status) === null || _b === void 0 ? void 0 : _b.chromeAvailability;
+        if (a === 'available')
+            return 'Installed';
+        if (a === 'downloading' || this.isInstalling)
+            return 'Downloading…';
+        if (a === 'downloadable')
+            return 'Downloadable';
+        if (a === 'unavailable')
+            return 'Unavailable';
+        return null;
+    }
+    get canInstall() {
+        var _a, _b, _c;
+        return (!!((_a = this.aiProvider) === null || _a === void 0 ? void 0 : _a.triggerDownload) &&
+            ((_b = this.status) === null || _b === void 0 ? void 0 : _b.provider) === 'chrome' &&
+            ((_c = this.status) === null || _c === void 0 ? void 0 : _c.chromeAvailability) === 'downloadable' &&
+            !this.isInstalling);
+    }
+    get isDownloading() {
+        var _a;
+        return ((_a = this.status) === null || _a === void 0 ? void 0 : _a.chromeAvailability) === 'downloading' || this.isInstalling;
+    }
+    connectedCallback() {
+        const _super = Object.create(null, {
+            connectedCallback: { get: () => super.connectedCallback }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            _super.connectedCallback.call(this);
+            yield this.refreshStatus();
+            this.maybeStartPolling();
+        });
+    }
+    disconnectedCallback() {
+        this.stopPolling();
+        document.removeEventListener('mousedown', this.clickOutside);
+    }
+    openChanged() {
+        if (this.open) {
+            document.addEventListener('mousedown', this.clickOutside);
+            this.refreshStatus();
+        }
+        else {
+            document.removeEventListener('mousedown', this.clickOutside);
+        }
+    }
+    handleClickOutside(event) {
+        if (wasClickOutsideElement(event, this)) {
+            this.open = false;
+        }
+    }
+    toggleDropdown() {
+        this.open = !this.open;
+    }
+    refreshStatus() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!((_a = this.aiProvider) === null || _a === void 0 ? void 0 : _a.getStatus)) {
+                this.status = null;
+                this.state = 'none';
+                return;
+            }
+            try {
+                const s = yield this.aiProvider.getStatus();
+                this.status = s;
+                this.state = this.deriveState(s);
+                if (this.state === 'available') {
+                    this.isInstalling = false;
+                }
+            }
+            catch (_b) {
+                this.status = null;
+                this.state = 'none';
+                this.isInstalling = false;
+            }
+        });
+    }
+    deriveState(s) {
+        if (!s || s.provider === 'none')
+            return 'none';
+        if (s.provider === 'chrome') {
+            const a = s.chromeAvailability;
+            if (a === 'available')
+                return 'available';
+            if (a === 'downloading')
+                return 'downloading';
+            if (a === 'downloadable')
+                return 'downloadable';
+            if (a === 'unavailable')
+                return 'unavailable';
+            return 'unavailable';
+        }
+        return 'server';
+    }
+    maybeStartPolling() {
+        var _a;
+        if (((_a = this.status) === null || _a === void 0 ? void 0 : _a.chromeAvailability) === 'downloading' || this.isInstalling) {
+            this.startPolling();
+        }
+        else {
+            this.stopPolling();
+        }
+    }
+    startPolling() {
+        if (this.pollTimer)
+            return;
+        this.pollTimer = setInterval(() => {
+            this.refreshStatus().then(() => {
+                this.maybeStartPolling();
+            });
+        }, POLL_INTERVAL_MS);
+    }
+    stopPolling() {
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+    }
+    onInstall() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!this.canInstall || !((_a = this.aiProvider) === null || _a === void 0 ? void 0 : _a.triggerDownload))
+                return;
+            this.isInstalling = true;
+            try {
+                yield this.aiProvider.triggerDownload();
+                this.startPolling();
+            }
+            catch (_b) {
+                this.isInstalling = false;
+            }
+            finally {
+                yield this.refreshStatus();
+            }
+        });
+    }
+}
+__decorate([
+    AIProvider
+], AiIndicator.prototype, "aiProvider", void 0);
+__decorate([
+    observable
+], AiIndicator.prototype, "status", void 0);
+__decorate([
+    observable
+], AiIndicator.prototype, "open", void 0);
+__decorate([
+    observable
+], AiIndicator.prototype, "state", void 0);
+__decorate([
+    observable
+], AiIndicator.prototype, "isInstalling", void 0);
+__decorate([
+    volatile
+], AiIndicator.prototype, "chromeStatusLabel", null);
+__decorate([
+    volatile
+], AiIndicator.prototype, "canInstall", null);
+__decorate([
+    volatile
+], AiIndicator.prototype, "isDownloading", null);
+export const foundationAiIndicator = AiIndicator.compose({
+    baseName: 'ai-indicator',
+    template,
+    styles,
+});

package/dist/esm/ai-indicator/ai-indicator.styles.js

@@ -0,0 +1,132 @@
+import { css } from '@microsoft/fast-element';
+export const foundationAiIndicatorStyles = (context, definition) => css `
+  :host {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    width: 100%;
+    margin: calc(var(--design-unit) * 2px) 0;
+    position: relative;
+
+    /* Same as connection indicator */
+    --green: 50 164 49;
+    --trafic-light-green: rgb(var(--green));
+    --red: 187 30 16;
+    --trafic-light-red: rgb(var(--red));
+    --amber: 230 160 20;
+    --trafic-light-amber: rgb(var(--amber));
+  }
+
+  .ai-indicator-container {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    position: relative;
+  }
+
+  .ai-indicator-badge {
+    display: inline-flex;
+    align-items: center;
+    gap: calc(var(--design-unit) * 1.4px);
+    font-size: 12px;
+    line-height: 1;
+    font-weight: 600;
+    text-transform: uppercase;
+    height: calc(var(--design-unit) * 6px);
+    padding: calc(var(--design-unit) * 0.5px) calc(var(--design-unit) * 2px);
+    border-radius: calc(var(--design-unit) * 1px);
+    cursor: pointer;
+    color: #fff;
+  }
+
+  .ai-indicator-badge:hover {
+    opacity: 90%;
+  }
+
+  .ai-indicator-badge.green {
+    background: var(--trafic-light-green);
+  }
+
+  .ai-indicator-badge.amber {
+    background: var(--trafic-light-amber);
+  }
+
+  .ai-indicator-badge.red {
+    background: var(--trafic-light-red);
+  }
+
+  .ai-indicator-badge .ai-indicator-icon {
+    flex-shrink: 0;
+    color: inherit;
+  }
+
+  .ai-indicator-badge.pulsing {
+    animation: ai-indicator-pulse 1.5s ease-in-out infinite;
+  }
+
+  @keyframes ai-indicator-pulse {
+    0%,
+    100% {
+      opacity: 100%;
+    }
+
+    50% {
+      opacity: 50%;
+    }
+  }
+
+  .ai-indicator-dropdown {
+    position: absolute;
+    top: 100%;
+    right: 0;
+    margin-top: calc(var(--design-unit) * 2px);
+    min-width: 200px;
+    padding: calc(var(--design-unit) * 4px);
+    background: var(--neutral-layer-floating, #fff);
+    border: 1px solid var(--neutral-stroke-rest, #e0e0e0);
+    border-radius: calc(var(--design-unit) * 2px);
+    box-shadow: 0 calc(var(--design-unit) * 1px) calc(var(--design-unit) * 4px) rgb(0 0 0 / 12%);
+    z-index: 1000;
+  }
+
+  .ai-indicator-info {
+    display: flex;
+    flex-direction: column;
+    gap: 0;
+    margin: 0;
+    padding: 0;
+  }
+
+  .ai-indicator-info .info-row {
+    display: grid;
+    grid-template-columns: 72px 1fr;
+    gap: calc(var(--design-unit) * 4px);
+    align-items: baseline;
+    padding: calc(var(--design-unit) * 1.5px) 0;
+    border-bottom: 1px solid var(--neutral-stroke-subtle, #eee);
+  }
+
+  .ai-indicator-info .info-row:last-child {
+    border-bottom: none;
+  }
+
+  .ai-indicator-info .info-label {
+    margin: 0;
+    font-size: var(--type-ramp-base-font-size);
+    font-weight: 500;
+    color: var(--neutral-foreground-hint, #666);
+  }
+
+  .ai-indicator-info .info-value {
+    margin: 0;
+    font-size: var(--type-ramp-base-font-size);
+    color: var(--neutral-foreground-rest, #333);
+    text-transform: capitalize;
+    word-break: break-word;
+  }
+
+  .install-button {
+    margin-top: calc(var(--design-unit) * 3px);
+    width: 100%;
+  }
+`;

package/dist/esm/ai-indicator/ai-indicator.template.js

@@ -0,0 +1,72 @@
+import { isAIFeatureEnabled } from '@genesislcap/foundation-ai';
+import { html, when } from '@microsoft/fast-element';
+import { classNames } from '@microsoft/fast-web-utilities';
+import { getPrefix } from '../utils';
+const aiIndicatorTemplate = (prefix) => html `
+  ${when(() => isAIFeatureEnabled(), html `
+  <div class="ai-indicator-container" part="ai-indicator-container">
+    <div
+      class=${(x) => classNames('ai-indicator-badge', ['green', x.state === 'available' || x.state === 'server'], ['amber', x.state === 'downloading' || x.state === 'downloadable'], ['red', x.state === 'unavailable' || x.state === 'none'], ['pulsing', x.state === 'downloading' || x.isInstalling])}
+      data-test-id="ai-indicator-badge"
+      part="ai-indicator-badge"
+      role="button"
+      tabindex="0"
+      aria-label="AI status"
+      aria-haspopup="true"
+      aria-expanded="${(x) => x.open}"
+      @click=${(x) => x.toggleDropdown()}
+      @keydown=${(x, c) => {
+    const e = c.event;
+    if (e.key === 'Enter' || e.key === ' ') {
+        e.preventDefault();
+        x.toggleDropdown();
+    }
+}}
+    >
+      <${prefix}-icon
+        class="ai-indicator-icon"
+        name="wand-magic-sparkles"
+        size="xs"
+        variant="solid"
+        part="ai-indicator-icon"
+      ></${prefix}-icon>
+      <span class="ai-indicator-text" data-test-id="ai-indicator-text" part="ai-indicator-text">AI</span>
+    </div>
+    ${when((x) => x.open, html `
+        <div class="ai-indicator-dropdown" part="ai-indicator-dropdown">
+          <dl class="ai-indicator-info">
+            <div class="info-row">
+              <dt class="info-label">Provider</dt>
+              <dd class="info-value">${(x) => { var _a, _b; return (_b = (_a = x.status) === null || _a === void 0 ? void 0 : _a.provider) !== null && _b !== void 0 ? _b : 'none'; }}</dd>
+            </div>
+            <div class="info-row">
+              <dt class="info-label">Model</dt>
+              <dd class="info-value">${(x) => { var _a; return ((_a = x.status) === null || _a === void 0 ? void 0 : _a.model) || '—'; }}</dd>
+            </div>
+            ${when((x) => x.chromeStatusLabel, html `
+                <div class="info-row">
+                  <dt class="info-label">Status</dt>
+                  <dd class="info-value">${(x) => x.chromeStatusLabel}</dd>
+                </div>
+              `)}
+          </dl>
+          ${when((x) => x.canInstall, html `
+              <${prefix}-button
+                class="install-button"
+                appearance="accent"
+                @click=${(x, c) => {
+    c.event.preventDefault();
+    x.onInstall();
+}}
+              >
+                Install model
+              </${prefix}-button>
+            `)}
+        </div>
+      `)}
+  </div>
+    `)}
+`;
+export const foundationAiIndicatorTemplate = html `
+  ${(x) => aiIndicatorTemplate(getPrefix(x))}
+`;

package/dist/esm/ai-indicator/index.js

@@ -0,0 +1,3 @@
+export { AiIndicator, foundationAiIndicator } from './ai-indicator';
+export { foundationAiIndicatorTemplate } from './ai-indicator.template';
+export { foundationAiIndicatorStyles } from './ai-indicator.styles';

package/dist/esm/base-components.js

@@ -2,6 +2,8 @@
 import { foundationAccordion } from './accordion';
 import { foundationAccordionItem } from './accordion-item';
 import { foundationActionsMenu } from './actions-menu';
+import { foundationAiCriteriaSearch } from './ai-criteria-search';
+import { foundationAiIndicator } from './ai-indicator';
 import { foundationAnchor } from './anchor';
 import { foundationAnchoredRegion } from './anchored-region';
 import { foundationAvatar } from './avatar';
@@ -84,6 +86,8 @@ import { foundationTreeView } from './tree-view';
 import { foundationUrlInput } from './url-input';
 export const baseComponents = {
     foundationAccordion,
+    foundationAiCriteriaSearch,
+    foundationAiIndicator,
     foundationAccordionItem,
     foundationActionsMenu,
     foundationAnchor,