@qoretechnologies/reqraft 0.10.13-pr.74.gccefa54 → 0.10.13

package/src/components/supportTicket/TicketReplyBox.stories.tsx

@@ -1,355 +0,0 @@
-import { ReqoreButton, ReqoreUIProvider } from '@qoretechnologies/reqore';
-import { StoryObj } from '@storybook/react-vite';
-import { expect, fn, screen, userEvent, waitFor, within } from 'storybook/test';
-import { StoryMeta } from '../../types';
-import { InterfaceReferenceTags } from './InterfaceReferenceTags';
-import { TicketReplyBox } from './TicketReplyBox';
-
-const meta = {
-  component: TicketReplyBox,
-  title: 'Components/TicketReplyBox',
-  args: {
-    onSend: fn(),
-  },
-} as StoryMeta<typeof TicketReplyBox>;
-
-export default meta;
-type Story = StoryObj<typeof meta>;
-
-/**
- * The customer composer, plain-editor variant (used here for a deterministic
- * type→send test): an attach button (no extra menu → a plain button, not a
- * dropdown) and Send. No internal-note toggle. Typing enables Send; clicking it
- * calls `onSend` with the body and `internal: false`.
- */
-export const Default: Story = {
-  parameters: {
-    docs: {
-      description: {
-        story:
-          "Renders the customer composer's plain-editor variant — an attach button and Send, no internal-note toggle; typing a reply enables Send, which calls onSend with the body and internal: false.",
-      },
-    },
-  },
-  args: { editor: 'plain' },
-  async play({ canvasElement, args }) {
-    const canvas = within(canvasElement);
-    const textarea = canvasElement.querySelector('textarea');
-    await expect(textarea).not.toBeNull();
-    await expect(canvas.queryByText('Internal note')).not.toBeInTheDocument();
-
-    await userEvent.type(textarea!, 'Here is my reply');
-    await userEvent.click(canvas.getByText('Send reply'));
-    await waitFor(() =>
-      expect(args.onSend).toHaveBeenCalledWith(
-        'Here is my reply',
-        expect.objectContaining({ internal: false })
-      )
-    );
-  },
-};
-
-/**
- * The staff composer (`allowInternalNote`): no toggle — the send button splits, so
- * the primary action posts a public reply and the caret opens "Add internal note",
- * which sends with `internal: true`.
- */
-export const StaffWithInternalNote: Story = {
-  parameters: {
-    docs: {
-      description: {
-        story:
-          "Renders the staff composer with a split send button — the primary action posts a public reply, while the caret opens 'Add internal note', which sends with internal: true.",
-      },
-    },
-  },
-  args: { allowInternalNote: true, editor: 'plain' },
-  async play({ canvasElement, args }) {
-    const canvas = within(canvasElement);
-    // no toggle any more; the primary action is a plain "Send reply"
-    await expect(canvas.queryByText('Internal note')).not.toBeInTheDocument();
-    await expect(canvas.getByText('Send reply')).toBeInTheDocument();
-
-    const textarea = canvasElement.querySelector('textarea');
-    await userEvent.type(textarea!, 'internal context');
-
-    // "Add internal note" lives behind the split-send caret
-    const caret = canvasElement.querySelector('.ticket-send-more');
-    await expect(caret).not.toBeNull();
-    await userEvent.click(caret as Element);
-    await userEvent.click(await screen.findByText('Add internal note'));
-
-    await waitFor(() =>
-      expect(args.onSend).toHaveBeenCalledWith(
-        'internal context',
-        expect.objectContaining({ internal: true })
-      )
-    );
-  },
-};
-
-/** A closed ticket replaces the editor with a muted notice. */
-export const Closed: Story = {
-  parameters: {
-    docs: {
-      description: {
-        story:
-          "Renders a closed ticket, where the disabled composer replaces the editor with a muted 'ticket is closed' notice.",
-      },
-    },
-  },
-  args: { disabled: true },
-  async play({ canvasElement }) {
-    await expect(within(canvasElement).getByText(/ticket is closed/i)).toBeInTheDocument();
-    await expect(canvasElement.querySelector('textarea')).toBeNull();
-  },
-};
-
-/**
- * The helpdesk composer as it now ships: the shared `<Composer>` with the rich,
- * Qonsole-style editor (`ReqoreRichTextEditor`) instead of a plain textarea. Staff
- * split-send, an attach dropdown (Upload + injected screenshot/capture), the
- * reference-interfaces toggle, and a reference chip below — all through the same
- * slots. Markdown still flows to `onSend` as a plain string. This is the input the
- * helpdesk uses.
- */
-export const RichHelpdeskReply: Story = {
-  parameters: {
-    docs: {
-      description: {
-        story:
-          'Renders the shipping helpdesk composer with the rich Qonsole-style editor — staff split-send, an attach dropdown, a reference-interfaces toggle, and an interface reference chip above the input.',
-      },
-    },
-  },
-  // Rendered under the Qorus theme (as in qorus-ide / admin-portal) so the
-  // `custom1` accent shows as the Qorus purple — a bare reqore theme greys it out.
-  decorators: [
-    (Story) => (
-      <ReqoreUIProvider theme={{ main: '#121212', intents: { custom1: '#762f7e' } }}>
-        <div style={{ padding: 20, background: '#121212' }}>
-          <Story />
-        </div>
-      </ReqoreUIProvider>
-    ),
-  ],
-  args: {
-    allowInternalNote: true,
-    defaultText:
-      "Thanks for the detailed report — we've reproduced the timeout and a fix is in review. In the meantime, can you confirm the datasource pool size configured for the sftp-partner connection?",
-    attachMenuItems: () => [
-      { label: 'Take screenshot', icon: 'CameraAiLine', onClick: fn() },
-      { label: 'Capture area', icon: 'CropLine', onClick: fn() },
-    ],
-    // the reference toggle, styled to the same custom1 accent as the send
-    footerActions: (
-      <ReqoreButton
-        icon='LinksLine'
-        minimal
-        flat
-        badge={1}
-        customTheme={{ main: 'custom1' }}
-        tooltip='Reference interfaces'
-      />
-    ),
-    // references on top of the editor (inside the bar), tinted to the accent — no
-    // "References" label, the chips read as the referenced interfaces on their own
-    aboveInput: (
-      <InterfaceReferenceTags
-        size='tiny'
-        references={[{ interface_kind: 'connection', interface_name: 'sftp-partner' }]}
-        customTheme={{ main: 'custom1' }}
-      />
-    ),
-  },
-  async play({ canvasElement }) {
-    const canvas = within(canvasElement);
-    // rich editor renders a Slate contenteditable (not a <textarea>) …
-    await expect(canvasElement.querySelector('[contenteditable="true"]')).not.toBeNull();
-    await expect(canvasElement.querySelector('textarea')).toBeNull();
-    // … the staff split-send caret is present …
-    await expect(canvasElement.querySelector('.ticket-send-more')).not.toBeNull();
-    // … and the reference chip renders on top (no "References" label).
-    await expect(canvas.getByText('sftp-partner')).toBeInTheDocument();
-    await expect(canvas.queryByText('References')).not.toBeInTheDocument();
-  },
-};
-
-/**
- * Every referenceable interface kind on one message, so the per-kind icons +
- * accent chip styling can be reviewed together: workflow, service, job, fsm,
- * connection, mapper, class, value-map, qog, ai-collection, ai-endpoint,
- * ai-guardrail. (`qog` has no built-in icon → the generic fallback.)
- */
-export const AllReferenceTypes: Story = {
-  parameters: {
-    docs: {
-      description: {
-        story:
-          'Renders a reply carrying every referenceable interface kind at once, so the per-kind icons and accent chip styling can be reviewed together (qog falls back to the generic glyph).',
-      },
-    },
-  },
-  decorators: [
-    (Story) => (
-      <ReqoreUIProvider theme={{ main: '#121212', intents: { custom1: '#762f7e' } }}>
-        <div style={{ padding: 20, background: '#121212' }}>
-          <Story />
-        </div>
-      </ReqoreUIProvider>
-    ),
-  ],
-  args: {
-    defaultText: 'This one references every interface kind.',
-    aboveInput: (
-      <InterfaceReferenceTags
-        size='tiny'
-        customTheme={{ main: 'custom1' }}
-        references={[
-          { interface_kind: 'workflow', interface_name: 'order-sync:1.2' },
-          { interface_kind: 'service', interface_name: 'notifier' },
-          { interface_kind: 'job', interface_name: 'nightly-recon' },
-          { interface_kind: 'fsm', interface_name: 'onboarding' },
-          { interface_kind: 'connection', interface_name: 'sftp-partner' },
-          { interface_kind: 'mapper', interface_name: 'csv-to-order' },
-          { interface_kind: 'class', interface_name: 'OrderUtils' },
-          { interface_kind: 'value-map', interface_name: 'country-codes' },
-          { interface_kind: 'qog', interface_name: 'daily-report' },
-          { interface_kind: 'ai-collection', interface_name: 'kb-support' },
-          { interface_kind: 'ai-endpoint', interface_name: 'gpt-router' },
-          { interface_kind: 'ai-guardrail', interface_name: 'pii-filter' },
-        ]}
-      />
-    ),
-  },
-  async play({ canvasElement }) {
-    const canvas = within(canvasElement);
-    await expect(canvas.getByText('workflow')).toBeInTheDocument();
-    await expect(canvas.getByText('ai-guardrail')).toBeInTheDocument();
-  },
-};
-
-// Stand-in app logos (a coloured rounded square + initial) as data-URIs, so the
-// story needs no network. Real logos come from the app catalogue (`app.logo`).
-const appLogo = (hex: string, letter: string) =>
-  `data:image/svg+xml,${encodeURIComponent(
-    `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><rect width="24" height="24" rx="6" fill="${hex}"/><text x="12" y="17" font-size="13" font-family="sans-serif" font-weight="bold" fill="#fff" text-anchor="middle">${letter}</text></svg>`
-  )}`;
-const APP_LOGOS: Record<string, string> = {
-  Telegram: appLogo('#2AABEE', 'T'),
-  Stripe: appLogo('#635BFF', 'S'),
-};
-
-/**
- * Faithful qog icons — a qog referenced by its trigger app shows that app's logo,
- * exactly like the qogs list. The customer's IDE resolves it live from the
- * reference's `trigger_app` via `resolveInterfaceImage` (it has the app catalogue);
- * a stored `logo` travels to viewers that don't (staff triage, the Qonsole card).
- * A qog with no trigger app falls back to the qog glyph.
- */
-export const QogTriggerAppLogo: Story = {
-  parameters: {
-    docs: {
-      description: {
-        story:
-          "Renders qogs referenced by their trigger apps, each showing that app's logo — resolved live via resolveInterfaceImage or from a stored logo — while a qog with no trigger app falls back to the qog glyph.",
-      },
-    },
-  },
-  decorators: [
-    (Story) => (
-      <ReqoreUIProvider theme={{ main: '#121212', intents: { custom1: '#762f7e' } }}>
-        <div style={{ padding: 20, background: '#121212' }}>
-          <Story />
-        </div>
-      </ReqoreUIProvider>
-    ),
-  ],
-  args: {
-    defaultText: 'These qogs are referenced by their trigger apps.',
-    aboveInput: (
-      <InterfaceReferenceTags
-        size='tiny'
-        customTheme={{ main: 'custom1' }}
-        references={[
-          // resolved live from trigger_app (the customer/IDE path)
-          { interface_kind: 'qog', interface_name: 'telegram-intake', trigger_app: 'Telegram' },
-          { interface_kind: 'qog', interface_name: 'stripe-billing', trigger_app: 'Stripe' },
-          // stored logo travels to viewers without the app catalogue (staff / Qonsole)
-          { interface_kind: 'qog', interface_name: 'slack-alerts', logo: appLogo('#4A154B', 'S') },
-          // no trigger app → the qog glyph fallback
-          { interface_kind: 'qog', interface_name: 'manual-recon' },
-        ]}
-        resolveInterfaceImage={(ref) => (ref.trigger_app ? APP_LOGOS[ref.trigger_app] : undefined)}
-      />
-    ),
-  },
-  async play({ canvasElement }) {
-    const canvas = within(canvasElement);
-    await expect(canvas.getByText('telegram-intake')).toBeInTheDocument();
-    // the trigger-app / stored-logo qogs render their app logo image
-    await expect(canvasElement.innerHTML).toContain('data:image');
-  },
-};
-
-// A stand-in "screenshot" as an SVG File so the story needs no real capture — the
-// composer's attachment strip renders any image File as a thumbnail (the real IDE
-// stages a PNG from captureScreenshot / captureRegion the same way).
-const screenshotFile = () => {
-  const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="260" height="150" viewBox="0 0 260 150">
-    <rect width="260" height="150" rx="8" fill="#0f0b16"/>
-    <rect width="260" height="26" fill="#1c1428"/>
-    <circle cx="16" cy="13" r="4" fill="#ff5f57"/><circle cx="32" cy="13" r="4" fill="#febc2e"/><circle cx="48" cy="13" r="4" fill="#28c840"/>
-    <rect x="16" y="44" width="110" height="12" rx="3" fill="#8e39a0"/>
-    <rect x="16" y="68" width="228" height="9" rx="3" fill="#2c2440"/>
-    <rect x="16" y="86" width="200" height="9" rx="3" fill="#2c2440"/>
-    <rect x="16" y="104" width="170" height="9" rx="3" fill="#2c2440"/>
-    <rect x="16" y="122" width="92" height="9" rx="3" fill="#2c2440"/>
-  </svg>`;
-  return new File([svg], 'region-capture.svg', { type: 'image/svg+xml' });
-};
-
-/**
- * A composed reply with both a staged screenshot (the attachment strip renders any
- * image File as a thumbnail — the real IDE stages a PNG from Take-screenshot /
- * Capture-area) and interface references on top.
- */
-export const WithScreenshotAndReferences: Story = {
-  parameters: {
-    docs: {
-      description: {
-        story:
-          'Renders a composed reply carrying both a staged screenshot thumbnail in the attachment strip and interface references above the input.',
-      },
-    },
-  },
-  decorators: [
-    (Story) => (
-      <ReqoreUIProvider theme={{ main: '#121212', intents: { custom1: '#762f7e' } }}>
-        <div style={{ padding: 20, background: '#121212' }}>
-          <Story />
-        </div>
-      </ReqoreUIProvider>
-    ),
-  ],
-  args: {
-    defaultText: "Here's the timeout I'm seeing on the nightly run — screenshot attached.",
-    defaultFiles: [screenshotFile()],
-    aboveInput: (
-      <InterfaceReferenceTags
-        size='tiny'
-        customTheme={{ main: 'custom1' }}
-        references={[
-          { interface_kind: 'connection', interface_name: 'sftp-partner' },
-          { interface_kind: 'qog', interface_name: 'telegram-intake', logo: appLogo('#2AABEE', 'T') },
-        ]}
-      />
-    ),
-  },
-  async play({ canvasElement }) {
-    const canvas = within(canvasElement);
-    // the staged screenshot thumbnail (an <img>) and the references both render
-    await expect(canvasElement.querySelector('img')).not.toBeNull();
-    await expect(canvas.getByText('sftp-partner')).toBeInTheDocument();
-  },
-};

package/src/components/supportTicket/TicketReplyBox.tsx

@@ -1,146 +0,0 @@
-import { ReqoreDropdown } from '@qoretechnologies/reqore';
-import { ComponentProps, ReactNode } from 'react';
-import { Composer, IComposerSendAction, TComposerEditor } from '../composer/Composer';
-import { fileToAttachment as defaultFileToAttachment } from './fileToAttachment';
-import { IAttachmentUpload } from './meta';
-
-/** The exact `items` shape ReqoreDropdown accepts — no import-path guessing. */
-type TAttachMenuItems = NonNullable<ComponentProps<typeof ReqoreDropdown>['items']>;
-
-export interface ITicketReplyBoxProps {
-  /** Send the composed message. `internal` is only ever true when
-   *  `allowInternalNote` is set (the staff surface). */
-  onSend: (
-    body: string,
-    options: { internal: boolean; attachments?: IAttachmentUpload[] }
-  ) => void | Promise<void>;
-  /** File → base64 upload conversion; defaults to the shared `fileToAttachment`. */
-  fileToAttachment?: (file: File) => Promise<IAttachmentUpload>;
-  /** the send round-trip is in flight */
-  sending?: boolean;
-  /** the ticket can't be replied to (e.g. closed) — renders a notice instead */
-  disabled?: boolean;
-  disabledReason?: string;
-  /** placeholder text. (A function is called with `false` — the mode is chosen at
-   *  send time, so there is no live internal-note mode.) */
-  placeholder?: string | ((internal: boolean) => string);
-  /** send labels; a function is called with `false` for the primary "Send reply"
-   *  and `true` for the "Add internal note" split-menu item. Defaults to
-   *  "Send reply" / "Add internal note". */
-  sendLabel?: string | ((internal: boolean) => string);
-  /** Staff surface: split the send button so it also offers "Add internal note"
-   *  (customer composers omit it and just send a reply). */
-  allowInternalNote?: boolean;
-  /** Extra attach-menu entries beyond "Upload files" — e.g. the IDE's screenshot /
-   *  region capture. Receives the composer's `addFiles`. With any entry the attach
-   *  control becomes a dropdown; otherwise it's a plain button. */
-  attachMenuItems?: (addFiles: (files: File[]) => void) => TAttachMenuItems;
-  /** Extra footer controls left of the send button — e.g. the IDE's
-   *  reference-interfaces toggle. */
-  footerActions?: ReactNode;
-  /** Rendered on top of the editor, inside the bar — e.g. reference chips. */
-  aboveInput?: ReactNode;
-  /** Rendered below the editor — e.g. the IDE's interface-reference picker. */
-  belowInput?: ReactNode;
-  /** Editor flavour. Helpdesk uses the rich, Qonsole-style editor by default; pass
-   *  `plain` for a simple textarea (e.g. deterministic play tests). */
-  editor?: TComposerEditor;
-  /** Initial draft text to seed the editor with (e.g. a restored draft). */
-  defaultText?: string;
-  /** Initial staged files (e.g. a restored draft's attachments, or a demo). */
-  defaultFiles?: File[];
-}
-
-/**
- * The shared ticket reply composer — now a thin adapter over the universal
- * `<Composer>` (the input extracted from qorus-ide's Qonsole chat). It maps the
- * ticket vocabulary onto the composer: the staff `allowInternalNote` becomes a
- * split send (primary "Send reply" + a caret "Add internal note", mode chosen at
- * send time), and staged files convert to `IAttachmentUpload[]` via
- * `fileToAttachment` before `onSend`. App-specific affordances still arrive
- * through slots (`attachMenuItems`, `footerActions`, `belowInput`), so the
- * IDE-only bits (screenshot capture, the reference picker) stay in qorus-ide. A
- * closed ticket renders a muted notice.
- */
-export const TicketReplyBox = ({
-  onSend,
-  fileToAttachment = defaultFileToAttachment,
-  sending,
-  disabled,
-  disabledReason = 'This ticket is closed. Open a new ticket to continue the conversation.',
-  placeholder = 'Write a reply…',
-  sendLabel,
-  allowInternalNote,
-  attachMenuItems,
-  footerActions,
-  aboveInput,
-  belowInput,
-  editor = 'rich',
-  defaultText,
-  defaultFiles,
-}: ITicketReplyBoxProps) => {
-  const resolvedPlaceholder =
-    typeof placeholder === 'function' ? placeholder(false) : placeholder;
-  // Label for a given send mode: `false` = public reply, `true` = internal note.
-  const labelFor = (note: boolean): string =>
-    sendLabel !== undefined
-      ? typeof sendLabel === 'function'
-        ? sendLabel(note)
-        : sendLabel
-      : note
-        ? 'Add internal note'
-        : 'Send reply';
-
-  // Staff surface splits the send button; customer surface is a single "Send reply".
-  // Both use the Qonsole-style minimal `custom1` accent (the Composer default); the
-  // internal note stays amber (`warning`) so it can't be mistaken for a public reply.
-  const sendActions: IComposerSendAction[] | undefined = allowInternalNote
-    ? [
-        {
-          id: 'reply',
-          label: labelFor(false),
-          icon: 'SendPlane2Line',
-          minimal: true,
-          customTheme: { main: 'custom1' },
-        },
-        {
-          id: 'internal',
-          label: labelFor(true),
-          icon: 'StickyNoteLine',
-          minimal: true,
-          intent: 'warning',
-        },
-      ]
-    : undefined;
-
-  const handleSend = async (
-    body: string,
-    { files, action }: { files: File[]; action?: string }
-  ): Promise<void> => {
-    const internal = action === 'internal';
-    const attachments = files.length
-      ? await Promise.all(files.map(fileToAttachment))
-      : undefined;
-    await onSend(body, { internal, attachments });
-  };
-
-  return (
-    <Composer
-      editor={editor}
-      defaultText={defaultText}
-      defaultFiles={defaultFiles}
-      placeholder={resolvedPlaceholder}
-      sending={sending}
-      disabled={disabled}
-      disabledReason={disabledReason}
-      onSend={handleSend}
-      sendLabel={labelFor(false)}
-      sendActions={sendActions}
-      sendMenuClassName='ticket-send-more'
-      attachMenuItems={attachMenuItems}
-      footerActions={footerActions}
-      aboveInput={aboveInput}
-      belowInput={belowInput}
-    />
-  );
-};

package/src/components/supportTicket/fileToAttachment.ts

@@ -1,24 +0,0 @@
-import { IAttachmentUpload } from './meta';
-
-/**
- * Read a picked `File` into the inline base64 upload shape the support API expects
- * (the SaaS plane accepts attachments as base64 on the create/reply payload, with
- * no separate multipart upload). Shared by every composer so the customer and
- * staff surfaces encode files identically.
- */
-export const fileToAttachment = (file: File): Promise<IAttachmentUpload> =>
-  new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.onerror = () => reject(new Error(`Could not read ${file.name}`));
-    reader.onload = () => {
-      // reader.result is a data URL: "data:<type>;base64,<content>"
-      const result = String(reader.result);
-      const content = result.slice(result.indexOf(',') + 1);
-      resolve({
-        filename: file.name,
-        content_type: file.type || 'application/octet-stream',
-        content,
-      });
-    };
-    reader.readAsDataURL(file);
-  });

package/src/components/supportTicket/index.ts

@@ -1,8 +0,0 @@
-export * from './meta';
-export * from './AttachmentChips';
-export * from './TicketMetaTags';
-export * from './TicketHeader';
-export * from './InterfaceReferenceTags';
-export * from './ReferencePicker';
-export * from './fileToAttachment';
-export * from './TicketReplyBox';

package/src/components/supportTicket/meta.ts

@@ -1,145 +0,0 @@
-import { TReqoreIntent } from '@qoretechnologies/reqore/dist/constants/theme';
-import { IReqoreIconName } from '@qoretechnologies/reqore/dist/types/icons';
-
-/*
- * The single source of truth for the Qorus support-ticket presentation
- * vocabulary — how each status / priority / category / audit-action value
- * renders (label + Reqore intent + icon), plus the interface-kind icon map and
- * the small enum helpers. Shared by every Qorus surface that shows a ticket
- * (the qorus-ide customer view, the admin-portal staff queue, the Qonsole
- * renderer) so the chips read identically everywhere and can't drift apart.
- */
-
-export type TTicketStatus = 'new' | 'open' | 'awaiting_customer' | 'resolved' | 'closed';
-export type TTicketPriority = 'low' | 'normal' | 'high' | 'urgent';
-export type TTicketCategory = 'bug' | 'question' | 'billing' | 'feature' | 'other';
-export type TTicketAuditAction = 'replied' | 'noted' | 'status_changed' | 'assigned' | 'updated';
-
-/** A message author. Staff identities are masked from the customer by the backend. */
-export type TTicketMessageAuthor = 'customer' | 'staff' | 'system';
-
-/** Which side "you" sit on — decides self-alignment and audience-specific labels. */
-export type TTicketViewerRole = 'customer' | 'staff';
-
-export interface ITicketEnumMeta {
-  label: string;
-  intent: TReqoreIntent;
-  icon: IReqoreIconName;
-  /** Audience-specific label for the customer view; falls back to `label` (the
-   *  staff / neutral wording). Only a few values differ by audience. */
-  customerLabel?: string;
-}
-
-export const TICKET_STATUS_META: Record<TTicketStatus, ITicketEnumMeta> = {
-  new: { label: 'New', intent: 'info', icon: 'SparklingLine' },
-  open: { label: 'Open', intent: 'pending', icon: 'Chat3Line' },
-  awaiting_customer: {
-    label: 'Awaiting customer',
-    customerLabel: 'Awaiting your reply',
-    intent: 'warning',
-    icon: 'UserReceivedLine',
-  },
-  resolved: { label: 'Resolved', intent: 'success', icon: 'CheckLine' },
-  closed: { label: 'Closed', intent: 'muted', icon: 'CloseCircleLine' },
-};
-
-export const TICKET_PRIORITY_META: Record<TTicketPriority, ITicketEnumMeta> = {
-  low: { label: 'Low', intent: 'muted', icon: 'ArrowDownLine' },
-  normal: { label: 'Normal', intent: 'info', icon: 'SubtractLine' },
-  high: { label: 'High', intent: 'warning', icon: 'ArrowUpLine' },
-  urgent: { label: 'Urgent', intent: 'danger', icon: 'AlarmWarningLine' },
-};
-
-export const TICKET_CATEGORY_META: Record<TTicketCategory, ITicketEnumMeta> = {
-  bug: { label: 'Bug', intent: 'danger', icon: 'BugLine' },
-  question: { label: 'Question', intent: 'info', icon: 'QuestionLine' },
-  billing: { label: 'Billing', intent: 'warning', icon: 'BankCardLine' },
-  feature: { label: 'Feature request', intent: 'success', icon: 'LightbulbLine' },
-  other: { label: 'Other', intent: 'muted', icon: 'MoreLine' },
-};
-
-/** Staff-only audit trail vocabulary (used by the admin-portal staff surface).
- *  These are exactly the actions the backend writes (qorus-api
- *  `QorusSaasTicketStore::insertAudit`): a public reply, an internal note, a
- *  status change, an assignment, or `updated` (a priority/category change). */
-export const TICKET_AUDIT_ACTION_META: Record<TTicketAuditAction, ITicketEnumMeta> = {
-  replied: { label: 'Replied', intent: 'success', icon: 'ReplyLine' },
-  noted: { label: 'Internal note', intent: 'info', icon: 'StickyNoteLine' },
-  status_changed: { label: 'Status changed', intent: 'warning', icon: 'ExchangeLine' },
-  assigned: { label: 'Assigned', intent: 'pending', icon: 'UserFollowLine' },
-  updated: { label: 'Updated', intent: 'muted', icon: 'Edit2Line' },
-};
-
-/** The status label for a given viewer — the customer sees "Awaiting your reply"
- *  where staff see "Awaiting customer"; all other values are audience-neutral. */
-export const ticketStatusLabel = (
-  status: TTicketStatus,
-  viewerRole?: TTicketViewerRole
-): string => {
-  const meta = TICKET_STATUS_META[status];
-  return viewerRole === 'customer' && meta.customerLabel ? meta.customerLabel : meta.label;
-};
-
-/** A reply may be sent while a ticket is in any state except `closed`. */
-export const REPLYABLE_STATUSES: TTicketStatus[] = [
-  'new',
-  'open',
-  'awaiting_customer',
-  'resolved',
-];
-
-/** Whether a ticket can still be replied to (closed ⇒ no). */
-export const isTicketReplyable = (status: TTicketStatus): boolean => status !== 'closed';
-
-/** A file to upload with a ticket or reply — raw bytes as base64, inline on the
- *  create/reply payload (the SaaS plane has no separate multipart upload). */
-export interface IAttachmentUpload {
-  filename: string;
-  content_type: string;
-  /** base64-encoded file content */
-  content: string;
-}
-
-/** A reference to a Qorus interface on the subscriber's instance, stored as a
- *  `{kind, name}` snapshot (the interface itself lives on the instance, not the
- *  SaaS plane). Attaches to a ticket (at creation) or a message (in a reply). */
-export interface IInterfaceReference {
-  /** interface type: workflow / service / job / fsm / qog / connection / ... */
-  interface_kind: string;
-  /** interface name (may include a version) */
-  interface_name: string;
-  /** server-assigned reference UUID (present on read, absent when submitting) */
-  reference_id?: string;
-  /** For an app-triggered interface (a qog): the triggering app's name. A viewer
-   *  with the app catalogue (the customer's IDE) resolves it to the app's logo the
-   *  same way the qogs list does — see `resolveInterfaceImage` on the tags. */
-  trigger_app?: string;
-  /** A pre-resolved logo/image (data-URI or URL) for the chip, e.g. the trigger
-   *  app's logo. Travels with the reference so a viewer without the app catalogue
-   *  (staff triage, the Qonsole card) still shows it. */
-  logo?: string;
-}
-
-// Built-in per-kind icons for referenced interfaces, kept in step with the
-// qorus-ide interface vocabulary. Used when a consumer doesn't pass its own
-// `resolveInterfaceIcon`, so the staff view and the Qonsole renderer show the
-// same chips as the customer view without each re-declaring the mapping.
-const DEFAULT_INTERFACE_ICONS: Record<string, IReqoreIconName> = {
-  workflow: 'GitBranchLine',
-  service: 'ServerLine',
-  job: 'CalendarLine',
-  fsm: 'DashboardLine',
-  // qog fallback glyph (used only when there's no trigger-app logo to show)
-  qog: 'FlowChart',
-  connection: 'Plug2Line',
-  mapper: 'MindMap',
-  class: 'CodeSLine',
-  'value-map': 'BringToFront',
-  'ai-collection': 'FileMarkedLine',
-  'ai-endpoint': 'RobotLine',
-  'ai-guardrail': 'ShieldLine',
-};
-
-/** Default per-kind icon for a referenced interface, with a generic fallback. */
-export const defaultInterfaceIcon = (kind: string): IReqoreIconName =>
-  DEFAULT_INTERFACE_ICONS[kind] ?? 'CodeBoxLine';