@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

package/dist/chunk-7TDO3CUM.js

@@ -0,0 +1,393 @@
+"use client";
+import {
+  userErrorText
+} from "./chunk-O4OOG3D6.js";
+
+// src/app/components/secrets/vault-model.tsx
+import {
+  vaultErrorCode,
+  vaultErrorDetail
+} from "@opengeni/sdk";
+import { resolveWorkspaceAgentDefaults } from "@opengeni/contracts";
+var VAULT_GROUP_TITLE = {
+  user: "Only me",
+  workspace: "This workspace"
+};
+function vaultGroup(vault) {
+  if (vault.ownerKind === "task") return null;
+  return vault.ownerKind === "user" ? "user" : "workspace";
+}
+function groupVaults(vaults) {
+  const order = ["user", "workspace"];
+  return order.map((id) => ({
+    id,
+    vaults: vaults.filter((vault) => vaultGroup(vault) === id).sort(
+      (a, b) => a.isDefault !== b.isDefault ? a.isDefault ? -1 : 1 : a.name.localeCompare(b.name)
+    )
+  })).filter((group) => group.vaults.length > 0);
+}
+function connectionOwnerLabel(owner) {
+  return OWNER_LABEL[owner];
+}
+function connectionAudience(owner, organizationName) {
+  return owner === "user" ? "Only you, and only work you start, can use its vaults." : owner === "workspace" ? "Everyone in this workspace can use its vaults." : `Workspaces in ${organizationName} can use its vaults.`;
+}
+function vaultsOfConnection(vaults, connectionId) {
+  return vaults.filter((vault) => vault.source !== "opengeni" && vault.providerConnectionId === connectionId).sort((a, b) => a.name.localeCompare(b.name));
+}
+var PLAN_LABEL = {
+  family: "Individual or Family",
+  teams: "Teams",
+  business: "Business"
+};
+var OWNER_LABEL = {
+  user: "Only me",
+  workspace: "This workspace",
+  organization: "Organization",
+  task: "This task"
+};
+var SOURCE_LABEL = {
+  opengeni: "Opengeni",
+  onepassword: "1Password",
+  host: "Your app",
+  external: "Your vault service",
+  protonpass: "Proton Pass",
+  keeper: "Keeper",
+  bitwarden: "Bitwarden"
+};
+var MODE_LABEL = {
+  read_only: "Read-only",
+  read_write: "Read & write"
+};
+function vaultAudience(vault, organizationName) {
+  switch (vault.ownerKind) {
+    case "user": {
+      const allowed = vault.availability?.allowedWorkspaceIds ?? null;
+      if (allowed === null) return "Only you, in all your workspaces";
+      const others = allowed.filter((id) => id !== vault.workspaceId).length;
+      if (others === 0) return "Only you, in your Personal workspace";
+      return `Only you, in Personal and ${others} other ${others === 1 ? "workspace" : "workspaces"}`;
+    }
+    case "task":
+      return "This task and its subtasks";
+    case "workspace":
+      return "Everyone in this workspace";
+    case "organization": {
+      const availability = vault.availability;
+      if (!availability || availability.allowedWorkspaceIds === null) {
+        return `Every workspace in ${organizationName}`;
+      }
+      const count = availability.allowedWorkspaceIds.length;
+      return `${count} ${count === 1 ? "workspace" : "workspaces"} in ${organizationName}`;
+    }
+  }
+}
+var ITEM_TYPE_LABEL = {
+  login: "Login",
+  api_key: "API key",
+  note: "Note",
+  file: "File",
+  passkey: "Passkey",
+  card: "Card",
+  identity: "Identity",
+  ssh_key: "SSH key"
+};
+function itemTypeNoun(type) {
+  return type === "api_key" || type === "ssh_key" ? ITEM_TYPE_LABEL[type] : ITEM_TYPE_LABEL[type].toLowerCase();
+}
+var CATEGORY_LABEL = {
+  wifi: "Wi-Fi",
+  driver_license: "Driver's license",
+  national_id: "National ID"
+};
+function itemCategoryLabel(category) {
+  const known = CATEGORY_LABEL[category];
+  if (known) return known;
+  const words = category.replace(/_/g, " ");
+  return words.charAt(0).toUpperCase() + words.slice(1);
+}
+function itemKindLabel(item) {
+  return item.category ? itemCategoryLabel(item.category) : ITEM_TYPE_LABEL[item.type];
+}
+var ITEM_TYPE_FILTERS = [
+  { value: "all", label: "All types" },
+  { value: "login", label: "Logins" },
+  { value: "api_key", label: "API keys" },
+  { value: "note", label: "Notes" },
+  { value: "card", label: "Cards" },
+  { value: "identity", label: "Identities" },
+  { value: "ssh_key", label: "SSH keys" },
+  { value: "file", label: "Files" },
+  { value: "passkey", label: "Passkeys" }
+];
+function itemsLabel(count) {
+  return `${count.toLocaleString()} ${count === 1 ? "item" : "items"}`;
+}
+function itemSubtitle(item) {
+  if (item.username) return item.username;
+  if (item.websites[0]) return hostOf(item.websites[0]);
+  return void 0;
+}
+function hostOf(website) {
+  try {
+    return new URL(website.includes("://") ? website : `https://${website}`).host;
+  } catch {
+    return website;
+  }
+}
+var EXPIRING_SOON_DAYS = 14;
+var DAY_MS = 864e5;
+function expiryState(expiresAt, now = Date.now()) {
+  if (!expiresAt) return null;
+  const at = new Date(expiresAt);
+  const ms = at.getTime() - now;
+  if (Number.isNaN(ms)) return null;
+  if (ms <= 0) return { kind: "expired", at };
+  const days = Math.ceil(ms / DAY_MS);
+  return days <= EXPIRING_SOON_DAYS ? { kind: "expiring", at, days } : null;
+}
+function expiryLabel(state) {
+  if (state.kind === "expired") return "Expired";
+  return state.days <= 1 ? "Expires today" : `Expires in ${state.days} days`;
+}
+function formatClock(iso) {
+  if (!iso) return null;
+  const date = new Date(iso);
+  if (Number.isNaN(date.getTime())) return null;
+  return date.toLocaleTimeString(void 0, {
+    hour: "2-digit",
+    minute: "2-digit",
+    hourCycle: "h23"
+  });
+}
+function syncLabel(vault) {
+  switch (vault.syncStatus) {
+    case "ok":
+      return null;
+    case "syncing":
+      return "Syncing";
+    case "error":
+      return "Sync failed";
+    case "auth_expired":
+      return "Token expired";
+    case "rate_limited": {
+      const until = formatClock(vault.rateLimitedUntil);
+      return until ? `Rate limited until ${until}` : "Rate limited";
+    }
+  }
+}
+var ERROR_COPY = {
+  vault_not_found: "This vault isn't here anymore. It may have been deleted.",
+  vault_item_not_found: "This item isn't here anymore. It may have been deleted or moved.",
+  vault_field_not_found: "This field isn't on the item anymore. Reload to see the latest version.",
+  vault_name_conflict: "A vault with this name already exists. Choose another name.",
+  vault_item_name_conflict: "An item with this name already exists in this vault. Choose another name.",
+  vault_limit_reached: "You've reached the vault limit. Delete a vault you no longer need first.",
+  vault_generation_conflict: "This changed elsewhere since you opened it. Reload to get the latest version.",
+  vault_permission_denied: "You don't have access to do this. Ask a workspace admin.",
+  vault_reveal_requires_human: "Only a person can reveal this value.",
+  vault_policy_outside_parent: "The parent task doesn't allow these vaults. Pick from the vaults it allows.",
+  encryption_key_missing: "Secrets can't be stored or read until the server's encryption key is set. Ask whoever runs this Opengeni server.",
+  secret_save_forbidden: "You can't save secrets there. Choose another place.",
+  invalid_secret_name: "Names can't contain /, {, }, # or \\, or start or end with a space.",
+  secret_value_too_large: "This value is too large. Text can be up to 64 KB and files up to 256 KB.",
+  human_auth_required: "Sign in again to continue."
+};
+var ONEPASSWORD_COPY = {
+  provider_auth_invalid: "1Password rejected this token. Check it's a service account token, then paste it again.",
+  provider_auth_expired: "The 1Password token expired. Paste a new service account token to reconnect."
+};
+function capitalized(text) {
+  return text.charAt(0).toUpperCase() + text.slice(1);
+}
+function providerCopy(code, home) {
+  if (home === "1Password" && ONEPASSWORD_COPY[code]) return ONEPASSWORD_COPY[code];
+  const where = home ?? "the password manager";
+  const Where = capitalized(where);
+  switch (code) {
+    case "vault_read_only":
+      return home ? `This vault is read-only. Change it in ${where} or link it as Read & write.` : "This vault is read-only. Link it as Read & write to save to it.";
+    case "vault_operation_unsupported":
+      return `${Where} can't do this here, though other changes still work. Use a workspace vault for it, or change it in ${where} itself.`;
+    case "provider_auth_invalid":
+      return `${Where} didn't accept the saved access. Reconnect it to keep using its vaults.`;
+    case "provider_auth_expired":
+      return `Access to ${where} expired. Reconnect it to keep using its vaults.`;
+    case "provider_rate_limited":
+      return `${Where} is limiting requests. Try again in a few minutes.`;
+    case "provider_unavailable":
+      return `${Where} didn't respond. Try again in a moment.`;
+    case "provider_conflict":
+      return `This item changed in ${where}. Sync, then try again.`;
+    case "provider_locked":
+      return `${Where} is locked. Unlock it, then try again.`;
+    case "provider_inventory_incomplete":
+      return `Not every item in ${where} could be listed. Try again in a moment.`;
+    case "provider_outcome_unknown":
+      return `${Where} didn't confirm the change. Check there before you try again, so nothing is saved twice.`;
+    default:
+      return void 0;
+  }
+}
+function vaultErrorText(error, fallback, home) {
+  const code = vaultErrorCode(error);
+  const where = home ?? homeOfError(error);
+  if (code === "provider_rate_limited") {
+    const retryAt = vaultErrorDetail(error, "retryAt");
+    const clock = typeof retryAt === "string" ? formatClock(retryAt) : null;
+    if (clock)
+      return `${capitalized(where ?? "the password manager")} is limiting requests. Try again after ${clock}.`;
+  }
+  const copy = code ? providerCopy(code, where) ?? ERROR_COPY[code] : void 0;
+  return copy ?? userErrorText(error, fallback);
+}
+var ERROR_HOMES = /* @__PURE__ */ new WeakMap();
+function homeOfError(error) {
+  return typeof error === "object" && error !== null ? ERROR_HOMES.get(error) ?? null : null;
+}
+function vaultError(error, fallback, home) {
+  if (home && typeof error === "object" && error !== null) ERROR_HOMES.set(error, home);
+  const wrapped = new Error(vaultErrorText(error, fallback, home));
+  wrapped.cause = error;
+  if (home) ERROR_HOMES.set(wrapped, home);
+  return wrapped;
+}
+function isMissingKeyError(error) {
+  return vaultErrorCode(error) === "encryption_key_missing";
+}
+function savedCreation(caught, itemName, vaultName) {
+  const error = caught?.cause ?? caught;
+  if (vaultErrorDetail(error, "saved") !== true) return null;
+  return {
+    title: `Saved ${itemName}`,
+    description: `It will appear in ${vaultName} after the next successful sync. Don't save it again.`
+  };
+}
+function createdManagedVault(caught, name) {
+  const error = caught?.cause ?? caught;
+  if (vaultErrorDetail(error, "created") !== true) return null;
+  const linked = vaultErrorDetail(error, "linked");
+  return {
+    name,
+    externalVaultId: stringDetail(error, "externalVaultId"),
+    vaultId: stringDetail(error, "vaultId"),
+    linked: typeof linked === "boolean" ? linked : null,
+    sharingUnconfirmed: vaultErrorDetail(error, "groupGrantConfirmed") === false,
+    errorCode: vaultErrorCode(error)
+  };
+}
+function managedVaultCreationText(created, home) {
+  let next;
+  if (created.linked) {
+    next = created.sharingUnconfirmed ? `It's linked, but group access wasn't confirmed. Check sharing in ${home}.` : "It's linked. Open the vault and sync it to check its items.";
+  } else if (created.linked === null) {
+    next = "Its link wasn't confirmed. Check the list before linking this existing vault.";
+  } else {
+    switch (created.errorCode) {
+      case "vault_name_conflict":
+        next = `A vault with this name already exists here. Rename that vault or the one in ${home}, then link the existing vault.`;
+        break;
+      case "vault_permission_denied":
+        next = "You don't have access to link it here. Ask a workspace admin to link the existing vault.";
+        break;
+      case "vault_limit_reached":
+        next = "The vault limit prevented linking. Free a place, then link the existing vault.";
+        break;
+      default:
+        next = "It isn't linked here. Choose its access, then link this existing vault.";
+    }
+  }
+  if (!created.linked && created.sharingUnconfirmed) next += ` Also check sharing in ${home}.`;
+  return `${next} Don't create it again.`;
+}
+function stringDetail(error, key) {
+  const value = vaultErrorDetail(error, key);
+  return typeof value === "string" && value ? value : null;
+}
+function savedTransfer(caught, context) {
+  const error = caught?.cause ?? caught;
+  if (vaultErrorDetail(error, "saved") !== true) return null;
+  const { mode, itemName, targetName, source, removal } = context;
+  const vaultId = stringDetail(error, "vaultId");
+  const itemId = stringDetail(error, "itemId");
+  const copy = vaultId && itemId ? { vaultId, itemId } : null;
+  const later = copy ? "" : ` It appears in ${targetName} after the next sync.`;
+  const originalRemoved = mode === "move" && vaultErrorDetail(error, "sourceArchived") === true;
+  if (mode === "copy" || originalRemoved) {
+    return {
+      title: mode === "move" ? `Moved ${itemName} to ${targetName}` : `Copied ${itemName} to ${targetName}`,
+      description: `${later.trim() || `It's saved in ${targetName}.`} Don't ${mode} it again.`,
+      copy,
+      originalRemoved
+    };
+  }
+  const removing = removal === "trash" ? "Trashing" : "Archiving";
+  const remove = removal === "trash" ? "move the original to trash" : "archive the original";
+  const again = "Don't move it again;";
+  const changed = vaultErrorDetail(error, "sourceChanged") === true;
+  const reason = !changed ? `${removing} the original in ${source} didn't finish. ${again} check ${source} and ${remove} if it's still there.` : vaultErrorCode(error) === "vault_item_not_found" ? `The original is no longer listed in ${source}. ${again} check ${source} for it.` : `${itemName} changed in ${source} during the move, so the original was kept. ${again} compare the two, then update the copy or ${remove}.`;
+  return {
+    title: `Saved a copy in ${targetName}`,
+    description: `${reason}${later}`,
+    copy,
+    originalRemoved: false
+  };
+}
+function isNotFoundError(error) {
+  const code = vaultErrorCode(error);
+  if (code === "vault_not_found" || code === "vault_item_not_found") return true;
+  return error?.status === 404;
+}
+function isPermissionError(error) {
+  if (vaultErrorCode(error) === "vault_permission_denied") return true;
+  return error?.status === 403;
+}
+function secretsOffIn(capabilities) {
+  if (capabilities === void 0) return null;
+  if (capabilities === "all") return false;
+  if (capabilities === "none") return true;
+  if (capabilities.secrets !== void 0) return !capabilities.secrets;
+  return capabilities.from === "none";
+}
+function secretsCapabilityOff(settings) {
+  return secretsOffIn(resolveWorkspaceAgentDefaults(settings)?.capabilities) ?? false;
+}
+
+export {
+  VAULT_GROUP_TITLE,
+  vaultGroup,
+  groupVaults,
+  connectionOwnerLabel,
+  connectionAudience,
+  vaultsOfConnection,
+  PLAN_LABEL,
+  OWNER_LABEL,
+  SOURCE_LABEL,
+  MODE_LABEL,
+  vaultAudience,
+  ITEM_TYPE_LABEL,
+  itemTypeNoun,
+  itemCategoryLabel,
+  itemKindLabel,
+  ITEM_TYPE_FILTERS,
+  itemsLabel,
+  itemSubtitle,
+  hostOf,
+  EXPIRING_SOON_DAYS,
+  expiryState,
+  expiryLabel,
+  formatClock,
+  syncLabel,
+  vaultErrorText,
+  vaultError,
+  isMissingKeyError,
+  savedCreation,
+  createdManagedVault,
+  managedVaultCreationText,
+  savedTransfer,
+  isNotFoundError,
+  isPermissionError,
+  secretsOffIn,
+  secretsCapabilityOff
+};
+//# sourceMappingURL=chunk-7TDO3CUM.js.map

package/dist/chunk-7TIX2UAR.js

@@ -0,0 +1,247 @@
+"use client";
+import {
+  ModelSettingsPlaceholder
+} from "./chunk-FCRIDEWQ.js";
+import {
+  returnToSearch
+} from "./chunk-BIFVNUK4.js";
+import {
+  FlushFormPage
+} from "./chunk-4E3ZJRTZ.js";
+import {
+  useNavigate
+} from "./chunk-BXBDYNRP.js";
+import {
+  FormDialog
+} from "./chunk-ZYAZUPPV.js";
+import {
+  userErrorText
+} from "./chunk-O4OOG3D6.js";
+import {
+  Field,
+  TextInput
+} from "./chunk-MVW6HNPI.js";
+import {
+  cn
+} from "./chunk-TXS65BB2.js";
+
+// src/app/components/models/models-ui.tsx
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useState
+} from "react";
+import { jsx } from "react/jsx-runtime";
+var ModelsListLabelContext = createContext("Models");
+var ModelsListLabelProvider = ModelsListLabelContext.Provider;
+function useModelsListLabel() {
+  return useContext(ModelsListLabelContext);
+}
+function modelsScopeLabels(organizationName, personal, workspaceName) {
+  return {
+    organization: `Shared by ${organizationName}`,
+    everyone: `Everyone in ${organizationName}`,
+    selected: "Selected workspaces",
+    none: "No workspaces",
+    workspace: personal ? "Personal workspace only" : workspaceName ? `${workspaceName} only` : "This workspace only",
+    user: "Only you"
+  };
+}
+function organizationReachLabel(labels, access) {
+  if (!access) return /* @__PURE__ */ jsx(ModelSettingsPlaceholder, {});
+  const { policy, personalWorkspacesSupported } = access;
+  if (policy.allowedPeople) return policy.allowedPeople.length ? "Selected people" : "No one";
+  const personal = personalWorkspacesSupported && policy.allowPersonalWorkspaces;
+  if (policy.allowedWorkspaces === null && (!personalWorkspacesSupported || personal))
+    return labels.everyone;
+  const reached = policy.allowedWorkspaces === null ? null : [.../* @__PURE__ */ new Set([...policy.allowedWorkspaces, ...access.localWorkspaceIds ?? []])];
+  if (reached !== null && reached.length === 0 && !personal) return labels.none;
+  if (reached?.length === 1 && !personal) {
+    const only = access.workspaces.find((workspace) => workspace.id === reached[0]);
+    if (only) return `${only.name} only`;
+  }
+  return labels.selected;
+}
+var NOT_IN_USE = /* @__PURE__ */ jsx("span", { className: "text-xs font-medium text-fg-subtle", children: "Not in use" });
+function accountReachLabel(labels, reach, workspaceName) {
+  if (reach.ownerWorkspaceId !== null) {
+    const owner = workspaceName(reach.ownerWorkspaceId);
+    const belongs = owner ? `Belongs to ${owner}` : "Belongs to a workspace";
+    const others = reach.workspaceIds.filter((id) => id !== reach.ownerWorkspaceId);
+    if (others.length === 0) return belongs;
+    const other = others.length === 1 ? workspaceName(others[0]) : void 0;
+    return other ? `${belongs}, also ${other}` : `${belongs}, also ${others.length} ${others.length === 1 ? "workspace" : "workspaces"}`;
+  }
+  if (reach.people !== null)
+    return reach.people === 0 ? "No one" : reach.people === 1 ? "1 person" : `${reach.people} people`;
+  if (reach.everyWorkspace) return reach.personalWorkspaces ? labels.everyone : "Shared workspaces";
+  const names = reach.workspaceIds.map((id) => workspaceName(id) ?? null);
+  const personal = reach.personalWorkspaces ? ["Personal workspaces"] : [];
+  if (names.length === 0) return personal[0] ?? labels.none;
+  if (names.length === 1 && personal.length === 0 && names[0]) return `${names[0]} only`;
+  if (names.length <= 2 && names.every((name) => name !== null))
+    return [...names, ...personal].join(", ");
+  return `${names.length} workspaces${personal.length ? " and Personal" : ""}`;
+}
+var MODELS_CONNECT_STEP_CLASS = "[&>form>header]:pt-4";
+function ModelsFormPage({
+  backLabel,
+  connectStep = false,
+  className,
+  ...props
+}) {
+  const listLabel = useModelsListLabel();
+  return /* @__PURE__ */ jsx(
+    FlushFormPage,
+    {
+      backLabel: backLabel ?? listLabel,
+      className: cn(connectStep && MODELS_CONNECT_STEP_CLASS, className),
+      ...props
+    }
+  );
+}
+function payerShortLabel(row) {
+  switch (row.billingClass) {
+    case "codex_subscription":
+      return "Codex";
+    case "claude_subscription":
+      return "Claude";
+    case "supergrok_subscription":
+      return "SuperGrok";
+    case "opengeni_credits":
+      return "Opengeni credits";
+    case "byok":
+    case "organization_byok":
+      return row.providerLabel;
+    default:
+      return row.providerLabel;
+  }
+}
+function payerLabel(billingClass, fallback) {
+  switch (billingClass) {
+    case "codex_subscription":
+      return "Codex plan";
+    case "claude_subscription":
+      return "Claude plan";
+    case "supergrok_subscription":
+      return "SuperGrok plan";
+    case "opengeni_credits":
+      return "Opengeni credits";
+    case "byok":
+      return "Workspace API key";
+    case "organization_byok":
+      return "Organization API key";
+    default:
+      return fallback ?? "Provider account";
+  }
+}
+function resetsLabel(count) {
+  if (typeof count !== "number" || count <= 0) return null;
+  return count === 1 ? "1 usage limit reset" : `${count} usage limit resets`;
+}
+function errorText(error, fallback) {
+  return userErrorText(error, fallback);
+}
+function useModelsNavigation(scope, current) {
+  const navigate = useNavigate();
+  const currentReturnTo = current.returnTo;
+  const go = useCallback(
+    (search) => {
+      const from = search.from ?? (search.account ? currentReturnTo : void 0);
+      const workspace = search.workspace === void 0 ? scope.workspaceId : search.workspace;
+      const next = {
+        section: "models",
+        ...workspace ? { workspace } : {},
+        ...search.account ? { account: search.account } : {},
+        ...search.view ? { view: search.view } : {},
+        ...returnToSearch(from)
+      };
+      void navigate({
+        to: "/workspaces/$workspaceId/organization",
+        params: { workspaceId: scope.anchorWorkspaceId },
+        search: next
+      });
+    },
+    [navigate, scope.anchorWorkspaceId, scope.workspaceId, currentReturnTo]
+  );
+  return {
+    account: current.account,
+    view: current.view,
+    returnTo: currentReturnTo,
+    openAccount: useCallback((account, from) => go({ account, from }), [go]),
+    openView: useCallback((view, account) => go({ account, view }), [go]),
+    openWorkspace: useCallback(
+      (workspace, account, view) => go({ workspace: workspace ?? null, account, view }),
+      [go]
+    ),
+    goBack: useCallback((returnTo) => void navigate({ href: returnTo.path }), [navigate])
+  };
+}
+function RenameAccountDialog({
+  open,
+  onOpenChange,
+  name,
+  label,
+  provider,
+  onSave
+}) {
+  const [value, setValue] = useState(label ?? "");
+  useEffect(() => {
+    if (open) setValue(label ?? "");
+  }, [open, label]);
+  const tooLong = value.trim().length > 64;
+  return /* @__PURE__ */ jsx(
+    FormDialog,
+    {
+      open,
+      onOpenChange,
+      size: "sm",
+      title: "Rename account",
+      description: `Shown in this list and the model picker. The ${provider} sign-in stays the same.`,
+      submitLabel: "Save name",
+      pendingLabel: "Saving\u2026",
+      submitDisabled: tooLong,
+      onSubmit: async () => {
+        await onSave(value);
+      },
+      onSubmitted: () => onOpenChange(false),
+      children: /* @__PURE__ */ jsx(
+        Field,
+        {
+          label: "Name",
+          hint: `Leave empty to show ${name === label ? "the account's email" : name}.`,
+          error: tooLong ? "Use 64 characters or fewer." : void 0,
+          aside: `${value.trim().length}/64`,
+          children: /* @__PURE__ */ jsx(
+            TextInput,
+            {
+              value,
+              suppressAutofill: true,
+              onChange: (event) => setValue(event.target.value)
+            }
+          )
+        }
+      )
+    }
+  );
+}
+
+export {
+  ModelsListLabelProvider,
+  useModelsListLabel,
+  modelsScopeLabels,
+  organizationReachLabel,
+  NOT_IN_USE,
+  accountReachLabel,
+  MODELS_CONNECT_STEP_CLASS,
+  ModelsFormPage,
+  payerShortLabel,
+  payerLabel,
+  resetsLabel,
+  errorText,
+  useModelsNavigation,
+  RenameAccountDialog
+};
+//# sourceMappingURL=chunk-7TIX2UAR.js.map