grm-shared-library 1.1.201 → 1.1.203

package/dist/types/modules/support/dtos/support-configuration.dto.d.ts

@@ -0,0 +1,130 @@
+import { CountryCode } from '../../country/enums/country-code.enum';
+import { IncidentAppId } from '../../incident/enums/incident-app-id.enum';
+import { SupportRelatedEntityType } from '../enums/support-related-entity-type.enum';
+import { SupportQueueAssignmentStrategy, SupportRoutingMatchType, SupportTeamMemberRole } from '../enums/support-routing.enum';
+import { SupportSlaClock } from '../enums/support-sla.enum';
+import { SupportTicketChannel } from '../enums/support-ticket-channel.enum';
+import { SupportTicketPriority } from '../enums/support-ticket-priority.enum';
+export declare class CreateSupportCategoryDto {
+    name: string;
+    code: string;
+    description?: string;
+    parentId?: string;
+    defaultPriority?: SupportTicketPriority;
+    defaultQueueId?: string;
+    expectedRelatedEntityType?: SupportRelatedEntityType;
+    displayOrder?: number;
+    organizationId?: number;
+}
+export declare class UpdateSupportCategoryDto {
+    name?: string;
+    description?: string;
+    parentId?: string;
+    defaultPriority?: SupportTicketPriority;
+    defaultQueueId?: string;
+    expectedRelatedEntityType?: SupportRelatedEntityType;
+    displayOrder?: number;
+    active?: boolean;
+}
+export declare class CreateSupportQueueDto {
+    name: string;
+    code: string;
+    description?: string;
+    teamId?: string;
+    countryCode?: CountryCode;
+    controlCentreId?: number;
+    assignmentStrategy?: SupportQueueAssignmentStrategy;
+    slaPolicyId?: string;
+    displayOrder?: number;
+    organizationId?: number;
+}
+export declare class UpdateSupportQueueDto {
+    name?: string;
+    description?: string;
+    teamId?: string;
+    countryCode?: CountryCode;
+    controlCentreId?: number;
+    assignmentStrategy?: SupportQueueAssignmentStrategy;
+    slaPolicyId?: string;
+    displayOrder?: number;
+    active?: boolean;
+}
+export declare class CreateSupportTeamDto {
+    name: string;
+    code: string;
+    description?: string;
+    supervisorUserIds?: number[];
+    organizationId?: number;
+}
+export declare class UpdateSupportTeamDto {
+    name?: string;
+    description?: string;
+    supervisorUserIds?: number[];
+    active?: boolean;
+}
+export declare class UpsertSupportTeamMemberDto {
+    userId: number;
+    role: SupportTeamMemberRole;
+    active?: boolean;
+}
+/** One priority row of an SLA policy. */
+export declare class SupportSlaPolicyTargetDto {
+    priority: SupportTicketPriority;
+    firstResponseMinutes: number;
+    resolutionMinutes: number;
+    clock: SupportSlaClock;
+}
+/** A working calendar for BUSINESS-clock targets. */
+export declare class SupportBusinessCalendarDto {
+    workingDays: number[];
+    startMinuteOfDay: number;
+    endMinuteOfDay: number;
+    timezone?: string;
+    holidays?: string[];
+}
+export declare class CreateSupportSlaPolicyDto {
+    name: string;
+    description?: string;
+    targets: SupportSlaPolicyTargetDto[];
+    businessCalendar?: SupportBusinessCalendarDto;
+    isDefault?: boolean;
+    organizationId?: number;
+}
+export declare class UpdateSupportSlaPolicyDto {
+    name?: string;
+    description?: string;
+    targets?: SupportSlaPolicyTargetDto[];
+    businessCalendar?: SupportBusinessCalendarDto;
+    isDefault?: boolean;
+    active?: boolean;
+}
+export declare class CreateSupportRoutingRuleDto {
+    name: string;
+    matchType: SupportRoutingMatchType;
+    matchCategoryId?: string;
+    matchPriority?: SupportTicketPriority;
+    matchChannel?: SupportTicketChannel;
+    matchCountryCode?: CountryCode;
+    matchControlCentreId?: number;
+    matchAppId?: IncidentAppId;
+    matchRelatedEntityType?: SupportRelatedEntityType;
+    targetQueueId: string;
+    forcePriority?: SupportTicketPriority;
+    priority?: number;
+    organizationId?: number;
+}
+export declare class UpdateSupportRoutingRuleDto {
+    name?: string;
+    matchType?: SupportRoutingMatchType;
+    matchCategoryId?: string;
+    matchPriority?: SupportTicketPriority;
+    matchChannel?: SupportTicketChannel;
+    matchCountryCode?: CountryCode;
+    matchControlCentreId?: number;
+    matchAppId?: IncidentAppId;
+    matchRelatedEntityType?: SupportRelatedEntityType;
+    targetQueueId?: string;
+    forcePriority?: SupportTicketPriority;
+    priority?: number;
+    active?: boolean;
+}

package/dist/types/modules/support/dtos/support-related-entity.dto.d.ts

@@ -0,0 +1,13 @@
+import { SupportRelatedEntityType } from '../enums/support-related-entity-type.enum';
+/**
+ * A pointer to a record owned by another service.
+ *
+ * The id is a string on the wire because the owning services disagree on the
+ * type - an incident is an integer, a chat conversation is a uuid - and a
+ * union on the wire is a union every client has to handle. clarion-support
+ * validates the shape per type before it stores one.
+ */
+export declare class SupportRelatedEntityDto {
+    type: SupportRelatedEntityType;
+    id: string;
+}

package/dist/types/modules/support/dtos/support-report-query.dto.d.ts

@@ -0,0 +1,29 @@
+import { CountryCode } from '../../country/enums/country-code.enum';
+import { CustomerFeedbackStatus, CustomerFeedbackType } from '../enums/support-feedback.enum';
+import { SupportTicketChannel } from '../enums/support-ticket-channel.enum';
+import { SupportTicketPriority } from '../enums/support-ticket-priority.enum';
+import { SupportTicketStatus } from '../enums/support-ticket-status.enum';
+/**
+ * Filters every support report accepts.
+ *
+ * `from`/`to` default to the last thirty days in the service rather than here,
+ * so an omitted range is a sensible report instead of a full-table scan on a
+ * dashboard that loads on login.
+ */
+export declare class SupportReportQueryDto {
+    from?: string;
+    to?: string;
+    organizationId?: number;
+    controlCentreId?: number;
+    countryCode?: CountryCode;
+    queueId?: string;
+    teamId?: string;
+    categoryId?: string;
+    agentUserId?: number;
+    status?: SupportTicketStatus;
+    priority?: SupportTicketPriority;
+    channel?: SupportTicketChannel;
+    feedbackType?: CustomerFeedbackType;
+    feedbackStatus?: CustomerFeedbackStatus;
+    granularity?: 'DAY' | 'WEEK' | 'MONTH';
+}

package/dist/types/modules/support/dtos/support-sync.dto.d.ts

@@ -0,0 +1,40 @@
+import { SupportProviderCode } from '../enums/support-provider-code.enum';
+import { SupportSyncEntityType, SupportSyncFailureReason, SupportSyncOperation, SupportSyncStatus } from '../enums/support-sync.enum';
+/** Filters for the synchronization dashboard. */
+export declare class SupportSyncQueryDto {
+    page?: number;
+    limit?: number;
+    status?: SupportSyncStatus;
+    operation?: SupportSyncOperation;
+    entityType?: SupportSyncEntityType;
+    failureReason?: SupportSyncFailureReason;
+    provider?: SupportProviderCode;
+    ticketId?: string;
+    organizationId?: number;
+    needsAttentionOnly?: boolean;
+    from?: string;
+    to?: string;
+}
+/**
+ * Put a failed synchronization row back in the queue.
+ *
+ * Deliberately not automatic for a dead-lettered row. It reached that state
+ * because the failure was permanent or the attempts ran out, and a retry loop
+ * that resurrects those on its own is a loop that re-sends the same broken
+ * request forever. A human decides, and the decision is audited.
+ */
+export declare class RetrySupportSyncDto {
+    reason?: string;
+    resetAttempts?: boolean;
+}
+/**
+ * Re-read a ticket from the provider and settle the differences.
+ *
+ * `dryRun` is the default for a reason: an operator should be able to see what
+ * reconciliation WOULD change before it changes anything, on a record a
+ * customer is actively reading.
+ */
+export declare class ReconcileSupportTicketDto {
+    dryRun?: boolean;
+    importMissingMessages?: boolean;
+}

package/dist/types/modules/support/dtos/support-ticket-actions.dto.d.ts

@@ -0,0 +1,61 @@
+import { SupportTicketPriority } from '../enums/support-ticket-priority.enum';
+import { SupportTicketStatus } from '../enums/support-ticket-status.enum';
+/**
+ * Change what a ticket is about. Agent-side only.
+ *
+ * Deliberately cannot change status, priority or assignment: those each have
+ * their own endpoint because each has its own permission, its own audit action
+ * and its own side effects on the SLA clocks. A single fat PATCH would collapse
+ * all three into one permission and one indistinguishable audit row.
+ */
+export declare class UpdateSupportTicketDto {
+    subject?: string;
+    categoryId?: string;
+    queueId?: string;
+}
+/** Give a ticket to an agent, a team, or both. */
+export declare class AssignSupportTicketDto {
+    assignedAgentId?: number;
+    assignedTeamId?: string;
+    queueId?: string;
+    reason?: string;
+}
+/**
+ * Move a ticket to another state.
+ *
+ * The transition is validated against the state machine, so an arbitrary status
+ * cannot be written. An invalid move is a 409, never a silent no-op.
+ */
+export declare class ChangeSupportTicketStatusDto {
+    status: SupportTicketStatus;
+    reason?: string;
+    message?: string;
+}
+/** Re-prioritise a ticket. Recalculates both SLA clocks from the original start. */
+export declare class ChangeSupportTicketPriorityDto {
+    priority: SupportTicketPriority;
+    reason?: string;
+}
+/** Replace a ticket's tags. Values are lower-cased and de-duplicated. */
+export declare class SetSupportTicketTagsDto {
+    tags: string[];
+}
+/**
+ * Close a ticket from the customer side.
+ *
+ * Separate from the agent status endpoint because the two carry different
+ * permissions and different meanings: a customer saying "this is sorted" is
+ * evidence about the outcome, an agent closing a ticket is a workflow action.
+ */
+export declare class CloseSupportTicketDto {
+    message?: string;
+}
+/** Reopen a closed ticket. Counted, so the reopen rate stays honest. */
+export declare class ReopenSupportTicketDto {
+    reason: string;
+}
+/** Attach documents already uploaded to clarion-dms. */
+export declare class AttachSupportDocumentsDto {
+    documentIds: number[];
+    messageId?: string;
+}

package/dist/types/modules/support/dtos/support-ticket-query.dto.d.ts

@@ -0,0 +1,41 @@
+import { CountryCode } from '../../country/enums/country-code.enum';
+import { SupportProviderCode } from '../enums/support-provider-code.enum';
+import { SupportSlaState } from '../enums/support-sla.enum';
+import { SupportTicketChannel } from '../enums/support-ticket-channel.enum';
+import { SupportTicketPriority } from '../enums/support-ticket-priority.enum';
+import { SupportTicketStatus } from '../enums/support-ticket-status.enum';
+/**
+ * Filters for a ticket list.
+ *
+ * Every field here NARROWS what the caller may already see. None of them widens
+ * it: `organizationId` is honoured only for a super-admin, and for anybody else
+ * the tenant scope comes from their trusted context and is applied in the
+ * repository regardless of what arrives here.
+ */
+export declare class SupportTicketQueryDto {
+    page?: number;
+    limit?: number;
+    search?: string;
+    sortBy?: string;
+    sortOrder?: 'ASC' | 'DESC';
+    status?: SupportTicketStatus;
+    activeOnly?: boolean;
+    priority?: SupportTicketPriority;
+    channel?: SupportTicketChannel;
+    countryCode?: CountryCode;
+    organizationId?: number;
+    controlCentreId?: number;
+    queueId?: string;
+    teamId?: string;
+    categoryId?: string;
+    assignedAgentId?: number;
+    unassignedOnly?: boolean;
+    customerUserId?: number;
+    slaState?: SupportSlaState;
+    breachedOnly?: boolean;
+    tag?: string;
+    externalProvider?: SupportProviderCode;
+    syncFailedOnly?: boolean;
+    from?: string;
+    to?: string;
+}

package/dist/types/modules/support/enums/support-audit-action.enum.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Every security- or business-sensitive thing that can happen in the support
+ * domain, as a closed vocabulary.
+ *
+ * A closed enum rather than free text because an audit trail nobody can query
+ * is not an audit trail. The admin filters on these values, and the operational
+ * runbook refers to them by name.
+ */
+export declare enum SupportAuditAction {
+    TICKET_CREATED = "TICKET_CREATED",
+    TICKET_UPDATED = "TICKET_UPDATED",
+    TICKET_ASSIGNED = "TICKET_ASSIGNED",
+    TICKET_REASSIGNED = "TICKET_REASSIGNED",
+    TICKET_UNASSIGNED = "TICKET_UNASSIGNED",
+    TICKET_STATUS_CHANGED = "TICKET_STATUS_CHANGED",
+    TICKET_PRIORITY_CHANGED = "TICKET_PRIORITY_CHANGED",
+    TICKET_CATEGORY_CHANGED = "TICKET_CATEGORY_CHANGED",
+    TICKET_QUEUE_CHANGED = "TICKET_QUEUE_CHANGED",
+    TICKET_CLOSED = "TICKET_CLOSED",
+    TICKET_REOPENED = "TICKET_REOPENED",
+    TICKET_CANCELLED = "TICKET_CANCELLED",
+    TICKET_TAGGED = "TICKET_TAGGED",
+    TICKET_UNTAGGED = "TICKET_UNTAGGED",
+    TICKET_WATCHER_ADDED = "TICKET_WATCHER_ADDED",
+    TICKET_WATCHER_REMOVED = "TICKET_WATCHER_REMOVED",
+    MESSAGE_ADDED = "MESSAGE_ADDED",
+    INTERNAL_NOTE_ADDED = "INTERNAL_NOTE_ADDED",
+    ATTACHMENT_ADDED = "ATTACHMENT_ADDED",
+    ATTACHMENT_ACCESSED = "ATTACHMENT_ACCESSED",
+    ATTACHMENT_REMOVED = "ATTACHMENT_REMOVED",
+    FEEDBACK_CREATED = "FEEDBACK_CREATED",
+    FEEDBACK_REVIEWED = "FEEDBACK_REVIEWED",
+    FEEDBACK_RESPONDED = "FEEDBACK_RESPONDED",
+    FEEDBACK_STATUS_CHANGED = "FEEDBACK_STATUS_CHANGED",
+    FEEDBACK_CONVERTED_TO_TICKET = "FEEDBACK_CONVERTED_TO_TICKET",
+    SLA_WARNING_RAISED = "SLA_WARNING_RAISED",
+    SLA_BREACHED = "SLA_BREACHED",
+    SLA_POLICY_CREATED = "SLA_POLICY_CREATED",
+    SLA_POLICY_UPDATED = "SLA_POLICY_UPDATED",
+    SLA_POLICY_DELETED = "SLA_POLICY_DELETED",
+    QUEUE_CREATED = "QUEUE_CREATED",
+    QUEUE_UPDATED = "QUEUE_UPDATED",
+    QUEUE_DELETED = "QUEUE_DELETED",
+    TEAM_CREATED = "TEAM_CREATED",
+    TEAM_UPDATED = "TEAM_UPDATED",
+    TEAM_DELETED = "TEAM_DELETED",
+    TEAM_MEMBER_ADDED = "TEAM_MEMBER_ADDED",
+    TEAM_MEMBER_REMOVED = "TEAM_MEMBER_REMOVED",
+    CATEGORY_CREATED = "CATEGORY_CREATED",
+    CATEGORY_UPDATED = "CATEGORY_UPDATED",
+    CATEGORY_DELETED = "CATEGORY_DELETED",
+    PROVIDER_SYNC_QUEUED = "PROVIDER_SYNC_QUEUED",
+    PROVIDER_SYNC_SUCCEEDED = "PROVIDER_SYNC_SUCCEEDED",
+    PROVIDER_SYNC_FAILED = "PROVIDER_SYNC_FAILED",
+    PROVIDER_SYNC_RETRIED = "PROVIDER_SYNC_RETRIED",
+    PROVIDER_SYNC_DEAD_LETTERED = "PROVIDER_SYNC_DEAD_LETTERED",
+    PROVIDER_RECONCILED = "PROVIDER_RECONCILED",
+    PROVIDER_WEBHOOK_RECEIVED = "PROVIDER_WEBHOOK_RECEIVED",
+    PROVIDER_WEBHOOK_REJECTED = "PROVIDER_WEBHOOK_REJECTED"
+}
+/** What the audit entry was about, so a trail can be read per record. */
+export declare enum SupportAuditEntityType {
+    TICKET = "TICKET",
+    TICKET_MESSAGE = "TICKET_MESSAGE",
+    TICKET_ATTACHMENT = "TICKET_ATTACHMENT",
+    FEEDBACK = "FEEDBACK",
+    QUEUE = "QUEUE",
+    TEAM = "TEAM",
+    CATEGORY = "CATEGORY",
+    SLA_POLICY = "SLA_POLICY",
+    PROVIDER_SYNC = "PROVIDER_SYNC"
+}
+/** Who performed the action. */
+export declare enum SupportActorType {
+    USER = "USER",
+    /** A background job inside clarion-support. */
+    SYSTEM = "SYSTEM",
+    /** A change that arrived from the helpdesk. */
+    PROVIDER = "PROVIDER"
+}

package/dist/types/modules/support/enums/support-feedback.enum.d.ts

@@ -0,0 +1,65 @@
+/**
+ * What a customer is telling us.
+ *
+ * Feedback stays inside Clarion whatever helpdesk is configured, so these
+ * values are never mapped onto a vendor's vocabulary and never leave the
+ * platform unless a piece of feedback is deliberately converted into a ticket.
+ */
+export declare enum CustomerFeedbackType {
+    BUG_REPORT = "BUG_REPORT",
+    FEATURE_REQUEST = "FEATURE_REQUEST",
+    COMPLAINT = "COMPLAINT",
+    COMPLIMENT = "COMPLIMENT",
+    GENERAL = "GENERAL",
+    /** A rating of the emergency or security service itself. */
+    SERVICE_RATING = "SERVICE_RATING",
+    /** A rating of a support interaction. */
+    SUPPORT_RATING = "SUPPORT_RATING"
+}
+/** The feedback types that carry a star rating and feed satisfaction reporting. */
+export declare const RATING_CUSTOMER_FEEDBACK_TYPES: readonly CustomerFeedbackType[];
+/** Where a piece of feedback is in its review workflow. */
+export declare enum CustomerFeedbackStatus {
+    NEW = "NEW",
+    UNDER_REVIEW = "UNDER_REVIEW",
+    /** Read and acknowledged, with no reply owed. */
+    ACKNOWLEDGED = "ACKNOWLEDGED",
+    /** A reply has been sent to the customer. */
+    RESPONDED = "RESPONDED",
+    /** Promoted into a ticket; `convertedTicketId` points at it. */
+    CONVERTED_TO_TICKET = "CONVERTED_TO_TICKET",
+    CLOSED = "CLOSED",
+    /** Spam, abuse or a test submission. Kept, never counted in satisfaction metrics. */
+    DISMISSED = "DISMISSED"
+}
+/** Transitions the feedback workflow permits. */
+export declare const CUSTOMER_FEEDBACK_TRANSITIONS: Readonly<Record<CustomerFeedbackStatus, readonly CustomerFeedbackStatus[]>>;
+/** Statuses that still need somebody to look at them. */
+export declare const OPEN_CUSTOMER_FEEDBACK_STATUSES: readonly CustomerFeedbackStatus[];
+/** Where the feedback was submitted from. */
+export declare enum CustomerFeedbackChannel {
+    MOBILE_APP = "MOBILE_APP",
+    WEB_APP = "WEB_APP",
+    AGENT_PORTAL = "AGENT_PORTAL",
+    API = "API"
+}
+/**
+ * Coarse sentiment.
+ *
+ * Derived from the feedback TYPE and rating only - never inferred from the
+ * message text. There is deliberately no classifier here: a wrong automated
+ * reading of "the guard never came" is worse than no reading at all. The field
+ * exists so a real classifier can be added later without a migration.
+ */
+export declare enum CustomerFeedbackSentiment {
+    POSITIVE = "POSITIVE",
+    NEUTRAL = "NEUTRAL",
+    NEGATIVE = "NEGATIVE",
+    UNKNOWN = "UNKNOWN"
+}
+/** Who wrote an entry in a feedback thread. */
+export declare enum CustomerFeedbackMessageAuthorType {
+    CUSTOMER = "CUSTOMER",
+    REVIEWER = "REVIEWER",
+    SYSTEM = "SYSTEM"
+}

package/dist/types/modules/support/enums/support-provider-code.enum.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Identifies the helpdesk platform a deployment operates support tickets on.
+ *
+ * Provider-neutral by design: the support domain in clarion-support - tickets,
+ * messages, feedback, queues, SLAs, audit and the whole REST surface - never
+ * branches on a specific helpdesk. Only the per-provider adapter inside that
+ * service understands a vendor's wire format, authentication and payload shape,
+ * and no vendor type is allowed to escape it.
+ *
+ * The value is stored on every ticket that has been mirrored outward, so a
+ * deployment that changes provider keeps an unambiguous record of which
+ * platform each historical ticket actually lives on. That is the whole reason
+ * it is persisted rather than read from configuration at display time.
+ */
+export declare enum SupportProviderCode {
+    /** Zammad - self-hosted, the platform default. */
+    ZAMMAD = "ZAMMAD",
+    /** Freshdesk - SaaS, the initial alternative. */
+    FRESHDESK = "FRESHDESK",
+    /**
+     * No external helpdesk. Clarion is the whole system of record.
+     *
+     * A first-class choice, not a failure state: an organization can run support
+     * entirely inside Clarion, and a deployment that has not finished
+     * provisioning a helpdesk still takes tickets rather than refusing them.
+     */
+    NONE = "NONE"
+}
+/** Providers that are actually mirrored to an external helpdesk. */
+export declare const EXTERNAL_SUPPORT_PROVIDERS: readonly SupportProviderCode[];
+/** The platform default when a deployment sets no provider at all. */
+export declare const DEFAULT_SUPPORT_PROVIDER: SupportProviderCode;
+/**
+ * What a helpdesk adapter is able to do.
+ *
+ * Published by each adapter rather than assumed, because helpdesks differ
+ * materially: both Zammad and Freshdesk can take a public reply, but only some
+ * deployments enable attachments, and a vendor without webhooks has to be
+ * reconciled by polling instead. The admin builds its buttons from this, so a
+ * capability a provider lacks is never offered to an operator as if it worked.
+ */
+export declare enum SupportProviderCapability {
+    CREATE_TICKET = "CREATE_TICKET",
+    UPDATE_TICKET = "UPDATE_TICKET",
+    PUBLIC_REPLY = "PUBLIC_REPLY",
+    INTERNAL_NOTE = "INTERNAL_NOTE",
+    ASSIGN_TICKET = "ASSIGN_TICKET",
+    CHANGE_STATUS = "CHANGE_STATUS",
+    CLOSE_REOPEN = "CLOSE_REOPEN",
+    ATTACHMENTS = "ATTACHMENTS",
+    CONTACTS = "CONTACTS",
+    SEARCH = "SEARCH",
+    /** The provider can push changes back to Clarion over a webhook. */
+    WEBHOOKS = "WEBHOOKS",
+    /** A single ticket can be re-read for reconciliation. */
+    FETCH_TICKET = "FETCH_TICKET"
+}

package/dist/types/modules/support/enums/support-related-entity-type.enum.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The kind of Clarion record a ticket or a piece of feedback is about.
+ *
+ * A reference only. clarion-support stores the type and the id and nothing
+ * else: it never copies an incident, an invoice or a chat message into its own
+ * schema, and it never declares a database foreign key across a service
+ * boundary.
+ *
+ * Ids are carried as text because the owning services do not agree on a type -
+ * incidents, organizations and newsfeed posts are integers, a chat conversation
+ * is a uuid. Storing the widest safe representation is what keeps this from
+ * needing a migration the first time one of them changes.
+ */
+export declare enum SupportRelatedEntityType {
+    INCIDENT = "INCIDENT",
+    BILLING_SUBSCRIPTION = "BILLING_SUBSCRIPTION",
+    BILLING_INVOICE = "BILLING_INVOICE",
+    BILLING_PAYMENT = "BILLING_PAYMENT",
+    BILLING_PACKAGE = "BILLING_PACKAGE",
+    CHAT_CONVERSATION = "CHAT_CONVERSATION",
+    NEWSFEED_POST = "NEWSFEED_POST",
+    NEWSFEED_COMMENT = "NEWSFEED_COMMENT",
+    PARTNER_DISPATCH = "PARTNER_DISPATCH",
+    RESPONSE_UNIT = "RESPONSE_UNIT",
+    ORGANIZATION = "ORGANIZATION",
+    USER = "USER",
+    /** A screen or feature in a client application, for contextual feedback. */
+    APP_SCREEN = "APP_SCREEN",
+    /** Another support ticket - a duplicate, or a follow-up. */
+    SUPPORT_TICKET = "SUPPORT_TICKET",
+    CUSTOMER_FEEDBACK = "CUSTOMER_FEEDBACK",
+    OTHER = "OTHER"
+}
+/**
+ * Related entities whose detail is fetched from another service for display.
+ *
+ * The admin ticket page enriches only these, and only for a reader who already
+ * passed that service's own authorization. Everything else is shown as a bare
+ * type and id, which is honest rather than broken.
+ */
+export declare const ENRICHABLE_SUPPORT_RELATED_ENTITY_TYPES: readonly SupportRelatedEntityType[];

package/dist/types/modules/support/enums/support-routing.enum.d.ts

@@ -0,0 +1,48 @@
+/**
+ * How a queue hands a ticket to an agent.
+ *
+ * Only MANUAL is honoured by the first implementation. The other members exist
+ * so that adding automatic assignment later is a service change and not a
+ * schema change, and so the admin can already show an operator what a queue
+ * will eventually do.
+ */
+export declare enum SupportQueueAssignmentStrategy {
+    /** A supervisor assigns. The queue is a shared inbox. */
+    MANUAL = "MANUAL",
+    /** Round-robin across available team members. Reserved. */
+    ROUND_ROBIN = "ROUND_ROBIN",
+    /** To whoever holds the fewest open tickets. Reserved. */
+    LEAST_BUSY = "LEAST_BUSY"
+}
+/**
+ * What a routing rule matches on.
+ *
+ * Rules are evaluated in priority order and the first match wins, so the
+ * dimensions are deliberately few and orthogonal. Anything cleverer belongs in
+ * a later classification service, not in a rule table an operator maintains by
+ * hand.
+ */
+export declare enum SupportRoutingMatchType {
+    /** Any ticket in the organization. The catch-all rule. */
+    ANY = "ANY",
+    CATEGORY = "CATEGORY",
+    PRIORITY = "PRIORITY",
+    CHANNEL = "CHANNEL",
+    COUNTRY = "COUNTRY",
+    CONTROL_CENTRE = "CONTROL_CENTRE",
+    /** The client application the ticket came from, e.g. G4S or GardaWorld. */
+    APP_ID = "APP_ID",
+    /** The kind of Clarion record the ticket is about. */
+    RELATED_ENTITY_TYPE = "RELATED_ENTITY_TYPE"
+}
+/** A support person's standing inside a team, independent of their platform role. */
+export declare enum SupportTeamMemberRole {
+    /** Works tickets. */
+    AGENT = "AGENT",
+    /** Works tickets, assigns them, and receives SLA warnings for the team. */
+    SUPERVISOR = "SUPERVISOR",
+    /** Owns the team's configuration and receives breach escalations. */
+    MANAGER = "MANAGER"
+}
+/** Team roles that receive SLA escalations, most junior first. */
+export declare const SUPPORT_ESCALATION_TEAM_ROLES: readonly SupportTeamMemberRole[];

package/dist/types/modules/support/enums/support-sla.enum.d.ts

@@ -0,0 +1,47 @@
+/** Where a ticket stands against one SLA target. */
+export declare enum SupportSlaState {
+    /** Inside the target with time to spare. */
+    ON_TRACK = "ON_TRACK",
+    /** Inside the target but past the warning threshold. */
+    WARNING = "WARNING",
+    /** The target elapsed without being met. */
+    BREACHED = "BREACHED",
+    /** The clock is stopped because the ticket is waiting on the customer. */
+    PAUSED = "PAUSED",
+    /** The target was met. Terminal. */
+    MET = "MET",
+    /** No policy applies, so there is nothing to be on track against. */
+    NOT_APPLICABLE = "NOT_APPLICABLE"
+}
+/** Which clock a state describes. A ticket carries one of each. */
+export declare enum SupportSlaTarget {
+    FIRST_RESPONSE = "FIRST_RESPONSE",
+    RESOLUTION = "RESOLUTION"
+}
+/** The kinds of SLA event recorded against a ticket, for audit and reporting. */
+export declare enum SupportSlaEventType {
+    /** A deadline was calculated for the first time. */
+    SCHEDULED = "SCHEDULED",
+    WARNING_RAISED = "WARNING_RAISED",
+    BREACHED = "BREACHED",
+    MET = "MET",
+    PAUSED = "PAUSED",
+    RESUMED = "RESUMED",
+    /** The applicable policy changed - a priority change, or a re-queue. */
+    RECALCULATED = "RECALCULATED",
+    /** The clocks were stopped without being met, e.g. the ticket was cancelled. */
+    CANCELLED = "CANCELLED"
+}
+/**
+ * How a policy measures elapsed time.
+ *
+ * CALENDAR runs around the clock; BUSINESS runs only inside the working
+ * calendar of the ticket's country. The distinction is not cosmetic: a NORMAL
+ * ticket raised at 17:00 on a Friday with an eight-hour calendar target is
+ * breached before anybody is back at a desk, which trains a support team to
+ * ignore the breach column entirely.
+ */
+export declare enum SupportSlaClock {
+    CALENDAR = "CALENDAR",
+    BUSINESS = "BUSINESS"
+}