@trii/types 2.10.656 → 2.10.657

package/dist/Tickets/Approval.d.ts

@@ -0,0 +1,139 @@
+import { ITicketAuditedEntity } from './Common';
+export declare enum TicketApprovalMode {
+    SEQUENTIAL = "SEQUENTIAL",
+    PARALLEL = "PARALLEL"
+}
+export declare enum TicketApprovalStatus {
+    PENDING = "PENDING",
+    IN_PROGRESS = "IN_PROGRESS",
+    APPROVED = "APPROVED",
+    REJECTED = "REJECTED",
+    CANCELLED = "CANCELLED",
+    EXPIRED = "EXPIRED"
+}
+export declare enum TicketApprovalDecisionType {
+    APPROVE = "APPROVE",
+    REJECT = "REJECT",
+    ABSTAIN = "ABSTAIN"
+}
+export declare enum TicketApprovalQuorumType {
+    ALL = "ALL",
+    ANY = "ANY",
+    COUNT = "COUNT",
+    PERCENTAGE = "PERCENTAGE"
+}
+export interface ITicketApprovalQuorum {
+    type: TicketApprovalQuorumType;
+    requiredCount?: number;
+    requiredPercentage?: number;
+    rejectOnAnyRejection?: boolean;
+}
+export type ITicketApprover = {
+    type: 'USER';
+    userId: string;
+} | {
+    type: 'GROUP';
+    groupId: string;
+} | {
+    type: 'ROLE';
+    roleId: string;
+};
+export interface ITicketApprovalStepDefinition {
+    id: string;
+    name: string;
+    order: number;
+    approvers: ITicketApprover[];
+    quorum: ITicketApprovalQuorum;
+    expiresAfterMinutes?: number;
+    allowDelegation: boolean;
+    escalationPolicyId?: string;
+}
+export interface ITicketApprovalProcessDefinition extends ITicketAuditedEntity {
+    name: string;
+    description?: string;
+    categoryIds?: string[];
+    mode: TicketApprovalMode;
+    steps: ITicketApprovalStepDefinition[];
+    enabled: boolean;
+}
+export interface ITicketApprovalStep extends ITicketApprovalStepDefinition {
+    status: TicketApprovalStatus;
+    startedAt?: Date;
+    expiresAt?: Date;
+    completedAt?: Date;
+}
+export interface ITicketApprovalProcess {
+    id: string;
+    spaceId: string;
+    ticketId: string;
+    definitionId?: string;
+    definitionVersion?: number;
+    name: string;
+    mode: TicketApprovalMode;
+    status: TicketApprovalStatus;
+    steps: ITicketApprovalStep[];
+    currentStepId?: string;
+    requestedAt: Date;
+    requestedBy: string;
+    completedAt?: Date;
+    cancelledAt?: Date;
+}
+export interface ITicketApprovalDecision {
+    id: string;
+    spaceId: string;
+    ticketId: string;
+    processId: string;
+    stepId: string;
+    approverId: string;
+    decision: TicketApprovalDecisionType;
+    comment?: string;
+    attachmentIds?: string[];
+    decidedAt: Date;
+    delegatedFromUserId?: string;
+}
+export interface ITicketApprovalDelegation {
+    id: string;
+    spaceId: string;
+    ticketId: string;
+    processId: string;
+    stepId: string;
+    fromUserId: string;
+    toUserId: string;
+    reason?: string;
+    delegatedAt: Date;
+    expiresAt?: Date;
+    revokedAt?: Date;
+}
+export interface ITicketApprovalSummary {
+    pending: number;
+    approved: number;
+    rejected: number;
+    expired: number;
+    currentProcessId?: string;
+}
+export interface IStartTicketApprovalDto {
+    expectedVersion: number;
+    definitionId: string;
+    comment?: string;
+}
+export interface IDecideTicketApprovalDto {
+    expectedVersion: number;
+    processId: string;
+    stepId: string;
+    decision: TicketApprovalDecisionType;
+    comment?: string;
+    attachmentIds?: string[];
+}
+export interface IDelegateTicketApprovalDto {
+    expectedVersion: number;
+    processId: string;
+    stepId: string;
+    toUserId: string;
+    reason?: string;
+    expiresAt?: Date;
+}
+export interface ICancelTicketApprovalDto {
+    expectedVersion: number;
+    processId: string;
+    reason: string;
+}

package/dist/Tickets/Approval.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TicketApprovalQuorumType = exports.TicketApprovalDecisionType = exports.TicketApprovalStatus = exports.TicketApprovalMode = void 0;
+var TicketApprovalMode;
+(function (TicketApprovalMode) {
+    TicketApprovalMode["SEQUENTIAL"] = "SEQUENTIAL";
+    TicketApprovalMode["PARALLEL"] = "PARALLEL";
+})(TicketApprovalMode || (exports.TicketApprovalMode = TicketApprovalMode = {}));
+var TicketApprovalStatus;
+(function (TicketApprovalStatus) {
+    TicketApprovalStatus["PENDING"] = "PENDING";
+    TicketApprovalStatus["IN_PROGRESS"] = "IN_PROGRESS";
+    TicketApprovalStatus["APPROVED"] = "APPROVED";
+    TicketApprovalStatus["REJECTED"] = "REJECTED";
+    TicketApprovalStatus["CANCELLED"] = "CANCELLED";
+    TicketApprovalStatus["EXPIRED"] = "EXPIRED";
+})(TicketApprovalStatus || (exports.TicketApprovalStatus = TicketApprovalStatus = {}));
+var TicketApprovalDecisionType;
+(function (TicketApprovalDecisionType) {
+    TicketApprovalDecisionType["APPROVE"] = "APPROVE";
+    TicketApprovalDecisionType["REJECT"] = "REJECT";
+    TicketApprovalDecisionType["ABSTAIN"] = "ABSTAIN";
+})(TicketApprovalDecisionType || (exports.TicketApprovalDecisionType = TicketApprovalDecisionType = {}));
+var TicketApprovalQuorumType;
+(function (TicketApprovalQuorumType) {
+    TicketApprovalQuorumType["ALL"] = "ALL";
+    TicketApprovalQuorumType["ANY"] = "ANY";
+    TicketApprovalQuorumType["COUNT"] = "COUNT";
+    TicketApprovalQuorumType["PERCENTAGE"] = "PERCENTAGE";
+})(TicketApprovalQuorumType || (exports.TicketApprovalQuorumType = TicketApprovalQuorumType = {}));

package/dist/Tickets/Automation.d.ts

@@ -0,0 +1,237 @@
+import { TicketPropertyValue } from "./Common";
+import { TicketSecurityOperation } from "./Security";
+/** Events published by Tickets that may start or resume a Flow execution. */
+export declare enum TicketAutomationTrigger {
+    TICKET_CREATED = "TICKET_CREATED",
+    TICKET_UPDATED = "TICKET_UPDATED",
+    STATUS_CHANGED = "STATUS_CHANGED",
+    PRIORITY_CHANGED = "PRIORITY_CHANGED",
+    ASSIGNMENT_CHANGED = "ASSIGNMENT_CHANGED",
+    CATEGORY_CHANGED = "CATEGORY_CHANGED",
+    PUBLIC_MESSAGE_RECEIVED = "PUBLIC_MESSAGE_RECEIVED",
+    PUBLIC_REPLY_SENT = "PUBLIC_REPLY_SENT",
+    INTERNAL_NOTE_ADDED = "INTERNAL_NOTE_ADDED",
+    SLA_WARNING = "SLA_WARNING",
+    SLA_BREACHED = "SLA_BREACHED",
+    TICKET_OVERDUE = "TICKET_OVERDUE",
+    APPROVAL_REQUESTED = "APPROVAL_REQUESTED",
+    APPROVAL_COMPLETED = "APPROVAL_COMPLETED",
+    APPROVAL_REJECTED = "APPROVAL_REJECTED",
+    TASK_CREATED = "TASK_CREATED",
+    TASK_COMPLETED = "TASK_COMPLETED",
+    TASK_OVERDUE = "TASK_OVERDUE",
+    SATISFACTION_RECEIVED = "SATISFACTION_RECEIVED",
+    TICKET_REOPENED = "TICKET_REOPENED",
+    TICKET_RESOLVED = "TICKET_RESOLVED",
+    SCHEDULED = "SCHEDULED",
+    MANUAL = "MANUAL"
+}
+/** Safe commands exposed by Tickets as Flow action nodes; every command uses normal domain validation. */
+export declare enum TicketAutomationAction {
+    UPDATE_FIELDS = "UPDATE_FIELDS",
+    CHANGE_STATUS = "CHANGE_STATUS",
+    SET_PRIORITY = "SET_PRIORITY",
+    ASSIGN_AGENT = "ASSIGN_AGENT",
+    ASSIGN_GROUP = "ASSIGN_GROUP",
+    ENQUEUE = "ENQUEUE",
+    ADD_TAG = "ADD_TAG",
+    REMOVE_TAG = "REMOVE_TAG",
+    ADD_INTERNAL_NOTE = "ADD_INTERNAL_NOTE",
+    SEND_PUBLIC_REPLY = "SEND_PUBLIC_REPLY",
+    SEND_NOTIFICATION = "SEND_NOTIFICATION",
+    START_APPROVAL = "START_APPROVAL",
+    APPLY_TASK_TEMPLATE = "APPLY_TASK_TEMPLATE",
+    LINK_TICKET = "LINK_TICKET",
+    CREATE_CHILD_TICKET = "CREATE_CHILD_TICKET",
+    MERGE_TICKETS = "MERGE_TICKETS",
+    PAUSE_SLA = "PAUSE_SLA",
+    RESUME_SLA = "RESUME_SLA",
+    CALL_WEBHOOK = "CALL_WEBHOOK"
+}
+export declare enum TicketAutomationCapabilityKind {
+    TRIGGER = "TRIGGER",
+    ACTION = "ACTION",
+    CONDITION = "CONDITION"
+}
+export declare enum TicketAutomationEventStatus {
+    PENDING = "PENDING",
+    PUBLISHED = "PUBLISHED",
+    FAILED = "FAILED",
+    DEAD_LETTER = "DEAD_LETTER"
+}
+export declare enum TicketAutomationActionStatus {
+    ACCEPTED = "ACCEPTED",
+    COMPLETED = "COMPLETED",
+    SKIPPED = "SKIPPED",
+    CONFLICT = "CONFLICT",
+    FAILED = "FAILED"
+}
+/** Causal metadata propagated across Tickets and Flow to deduplicate work and detect recursive loops. */
+export interface ITicketAutomationEnvelope {
+    eventId: string;
+    correlationId: string;
+    causationId?: string;
+    flowId?: string;
+    flowVersion?: number;
+    executionId?: string;
+    actionId?: string;
+    depth: number;
+    occurredAt: Date;
+}
+/** Snapshot and delta delivered to Flow when a ticket trigger fires. */
+export interface ITicketAutomationContext {
+    ticketId: string;
+    spaceId: string;
+    eventType: TicketAutomationTrigger;
+    ticketVersion: number;
+    changedFields?: string[];
+    previousValues?: {
+        [key: string]: TicketPropertyValue;
+    };
+    currentValues?: {
+        [key: string]: TicketPropertyValue;
+    };
+    conversationId?: string;
+    messageId?: string;
+    slaMetricCycleId?: string;
+    approvalProcessId?: string;
+    taskId?: string;
+    actorId?: string;
+}
+/** Transactional-outbox record. Tickets persists this with the mutation before publishing it to Flow. */
+export interface ITicketAutomationEvent {
+    id: string;
+    spaceId: string;
+    ticketId: string;
+    envelope: ITicketAutomationEnvelope;
+    context: ITicketAutomationContext;
+    status: TicketAutomationEventStatus;
+    attempts: number;
+    createdAt: Date;
+    publishedAt?: Date;
+    nextAttemptAt?: Date;
+    lastError?: string;
+}
+/** Minimal JSON-schema-compatible description used by the visual Flow editor to render node inputs. */
+export interface ITicketAutomationSchema {
+    type: "object";
+    title?: string;
+    description?: string;
+    required?: string[];
+    properties: {
+        [key: string]: ITicketAutomationSchemaProperty;
+    };
+}
+export interface ITicketAutomationSchemaProperty {
+    type: "string" | "number" | "integer" | "boolean" | "array" | "object";
+    title?: string;
+    description?: string;
+    format?: string;
+    enum?: TicketPropertyValue[];
+    default?: TicketPropertyValue;
+    items?: ITicketAutomationSchemaProperty;
+}
+/** Capability catalog entry consumed by Flow so ticket nodes are not hard-coded in its editor. */
+export interface ITicketAutomationCapability {
+    code: string;
+    kind: TicketAutomationCapabilityKind;
+    name: string;
+    description?: string;
+    trigger?: TicketAutomationTrigger;
+    action?: TicketAutomationAction;
+    inputSchema?: ITicketAutomationSchema;
+    outputSchema?: ITicketAutomationSchema;
+    requiredOperations?: TicketSecurityOperation[];
+    enabled: boolean;
+    version: number;
+}
+/** Query used by Flow to discover available ticket triggers, actions and conditions for a tenant. */
+export interface ITicketAutomationCapabilityQuery {
+    kinds?: TicketAutomationCapabilityKind[];
+    enabledOnly?: boolean;
+    version?: number;
+}
+/** Idempotent command sent by a Flow action node to the Tickets API. */
+export interface IExecuteTicketAutomationActionDto {
+    ticketId: string;
+    expectedVersion?: number;
+    action: TicketAutomationAction;
+    parameters: {
+        [key: string]: TicketPropertyValue;
+    };
+    envelope: ITicketAutomationEnvelope;
+    idempotencyKey: string;
+}
+/** Result stored by Flow; repeated idempotency keys must return the original result. */
+export interface ITicketAutomationActionResult {
+    ticketId: string;
+    action: TicketAutomationAction;
+    status: TicketAutomationActionStatus;
+    previousVersion?: number;
+    currentVersion?: number;
+    output?: {
+        [key: string]: TicketPropertyValue;
+    };
+    eventIds?: string[];
+    errorCode?: string;
+    errorMessage?: string;
+    retryable?: boolean;
+    completedAt: Date;
+}
+/** Audit record proving which flow/node caused a ticket mutation, independently from Flow logs. */
+export interface ITicketAutomationActionExecution {
+    id: string;
+    spaceId: string;
+    ticketId: string;
+    flowId: string;
+    flowVersion?: number;
+    executionId: string;
+    nodeId?: string;
+    actionId: string;
+    action: TicketAutomationAction;
+    idempotencyKey: string;
+    status: TicketAutomationActionStatus;
+    startedAt: Date;
+    completedAt?: Date;
+    result?: ITicketAutomationActionResult;
+}
+/** Tenant safety limits enforced by Tickets before accepting Flow-originated actions. */
+export interface ITicketAutomationLimits {
+    spaceId: string;
+    maximumCausalDepth: number;
+    maximumActionsPerExecution: number;
+    maximumActionsPerTicketPerMinute: number;
+    maximumEventsPerTicketPerMinute: number;
+    ignoreSameFlowCausedEvents: boolean;
+    deadLetterAfterAttempts: number;
+}
+/** Loop-check request evaluated before dispatching an event or executing an action. */
+export interface ITicketAutomationGuardRequest {
+    ticketId: string;
+    envelope: ITicketAutomationEnvelope;
+    action?: TicketAutomationAction;
+}
+export interface ITicketAutomationGuardDecision {
+    allowed: boolean;
+    reasonCode?: string;
+    reason?: string;
+    currentDepth: number;
+    actionsUsed?: number;
+    actionsRemaining?: number;
+}
+/** Registers the Flow binding that determines which ticket event starts which flow version. */
+export interface ITicketFlowBinding {
+    id: string;
+    spaceId: string;
+    name: string;
+    trigger: TicketAutomationTrigger;
+    flowId: string;
+    flowVersion?: number;
+    categoryIds?: string[];
+    enabled: boolean;
+    ignoreEventsCausedBySameFlow: boolean;
+    createdAt: Date;
+    createdBy: string;
+    updatedAt?: Date;
+    updatedBy?: string;
+}

package/dist/Tickets/Automation.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TicketAutomationActionStatus = exports.TicketAutomationEventStatus = exports.TicketAutomationCapabilityKind = exports.TicketAutomationAction = exports.TicketAutomationTrigger = void 0;
+/** Events published by Tickets that may start or resume a Flow execution. */
+var TicketAutomationTrigger;
+(function (TicketAutomationTrigger) {
+    TicketAutomationTrigger["TICKET_CREATED"] = "TICKET_CREATED";
+    TicketAutomationTrigger["TICKET_UPDATED"] = "TICKET_UPDATED";
+    TicketAutomationTrigger["STATUS_CHANGED"] = "STATUS_CHANGED";
+    TicketAutomationTrigger["PRIORITY_CHANGED"] = "PRIORITY_CHANGED";
+    TicketAutomationTrigger["ASSIGNMENT_CHANGED"] = "ASSIGNMENT_CHANGED";
+    TicketAutomationTrigger["CATEGORY_CHANGED"] = "CATEGORY_CHANGED";
+    TicketAutomationTrigger["PUBLIC_MESSAGE_RECEIVED"] = "PUBLIC_MESSAGE_RECEIVED";
+    TicketAutomationTrigger["PUBLIC_REPLY_SENT"] = "PUBLIC_REPLY_SENT";
+    TicketAutomationTrigger["INTERNAL_NOTE_ADDED"] = "INTERNAL_NOTE_ADDED";
+    TicketAutomationTrigger["SLA_WARNING"] = "SLA_WARNING";
+    TicketAutomationTrigger["SLA_BREACHED"] = "SLA_BREACHED";
+    TicketAutomationTrigger["TICKET_OVERDUE"] = "TICKET_OVERDUE";
+    TicketAutomationTrigger["APPROVAL_REQUESTED"] = "APPROVAL_REQUESTED";
+    TicketAutomationTrigger["APPROVAL_COMPLETED"] = "APPROVAL_COMPLETED";
+    TicketAutomationTrigger["APPROVAL_REJECTED"] = "APPROVAL_REJECTED";
+    TicketAutomationTrigger["TASK_CREATED"] = "TASK_CREATED";
+    TicketAutomationTrigger["TASK_COMPLETED"] = "TASK_COMPLETED";
+    TicketAutomationTrigger["TASK_OVERDUE"] = "TASK_OVERDUE";
+    TicketAutomationTrigger["SATISFACTION_RECEIVED"] = "SATISFACTION_RECEIVED";
+    TicketAutomationTrigger["TICKET_REOPENED"] = "TICKET_REOPENED";
+    TicketAutomationTrigger["TICKET_RESOLVED"] = "TICKET_RESOLVED";
+    TicketAutomationTrigger["SCHEDULED"] = "SCHEDULED";
+    TicketAutomationTrigger["MANUAL"] = "MANUAL";
+})(TicketAutomationTrigger || (exports.TicketAutomationTrigger = TicketAutomationTrigger = {}));
+/** Safe commands exposed by Tickets as Flow action nodes; every command uses normal domain validation. */
+var TicketAutomationAction;
+(function (TicketAutomationAction) {
+    TicketAutomationAction["UPDATE_FIELDS"] = "UPDATE_FIELDS";
+    TicketAutomationAction["CHANGE_STATUS"] = "CHANGE_STATUS";
+    TicketAutomationAction["SET_PRIORITY"] = "SET_PRIORITY";
+    TicketAutomationAction["ASSIGN_AGENT"] = "ASSIGN_AGENT";
+    TicketAutomationAction["ASSIGN_GROUP"] = "ASSIGN_GROUP";
+    TicketAutomationAction["ENQUEUE"] = "ENQUEUE";
+    TicketAutomationAction["ADD_TAG"] = "ADD_TAG";
+    TicketAutomationAction["REMOVE_TAG"] = "REMOVE_TAG";
+    TicketAutomationAction["ADD_INTERNAL_NOTE"] = "ADD_INTERNAL_NOTE";
+    TicketAutomationAction["SEND_PUBLIC_REPLY"] = "SEND_PUBLIC_REPLY";
+    TicketAutomationAction["SEND_NOTIFICATION"] = "SEND_NOTIFICATION";
+    TicketAutomationAction["START_APPROVAL"] = "START_APPROVAL";
+    TicketAutomationAction["APPLY_TASK_TEMPLATE"] = "APPLY_TASK_TEMPLATE";
+    TicketAutomationAction["LINK_TICKET"] = "LINK_TICKET";
+    TicketAutomationAction["CREATE_CHILD_TICKET"] = "CREATE_CHILD_TICKET";
+    TicketAutomationAction["MERGE_TICKETS"] = "MERGE_TICKETS";
+    TicketAutomationAction["PAUSE_SLA"] = "PAUSE_SLA";
+    TicketAutomationAction["RESUME_SLA"] = "RESUME_SLA";
+    TicketAutomationAction["CALL_WEBHOOK"] = "CALL_WEBHOOK";
+})(TicketAutomationAction || (exports.TicketAutomationAction = TicketAutomationAction = {}));
+var TicketAutomationCapabilityKind;
+(function (TicketAutomationCapabilityKind) {
+    TicketAutomationCapabilityKind["TRIGGER"] = "TRIGGER";
+    TicketAutomationCapabilityKind["ACTION"] = "ACTION";
+    TicketAutomationCapabilityKind["CONDITION"] = "CONDITION";
+})(TicketAutomationCapabilityKind || (exports.TicketAutomationCapabilityKind = TicketAutomationCapabilityKind = {}));
+var TicketAutomationEventStatus;
+(function (TicketAutomationEventStatus) {
+    TicketAutomationEventStatus["PENDING"] = "PENDING";
+    TicketAutomationEventStatus["PUBLISHED"] = "PUBLISHED";
+    TicketAutomationEventStatus["FAILED"] = "FAILED";
+    TicketAutomationEventStatus["DEAD_LETTER"] = "DEAD_LETTER";
+})(TicketAutomationEventStatus || (exports.TicketAutomationEventStatus = TicketAutomationEventStatus = {}));
+var TicketAutomationActionStatus;
+(function (TicketAutomationActionStatus) {
+    TicketAutomationActionStatus["ACCEPTED"] = "ACCEPTED";
+    TicketAutomationActionStatus["COMPLETED"] = "COMPLETED";
+    TicketAutomationActionStatus["SKIPPED"] = "SKIPPED";
+    TicketAutomationActionStatus["CONFLICT"] = "CONFLICT";
+    TicketAutomationActionStatus["FAILED"] = "FAILED";
+})(TicketAutomationActionStatus || (exports.TicketAutomationActionStatus = TicketAutomationActionStatus = {}));

package/dist/Tickets/Category.d.ts

@@ -0,0 +1,25 @@
+import { ITicketAuditedEntity, TicketPriority } from './Common';
+import { ITicketFormRequirement } from './Workflow';
+export interface ITicketCategory extends ITicketAuditedEntity {
+    name: string;
+    description?: string;
+    parentCategoryId?: string;
+    order: number;
+    enabled: boolean;
+    defaultPriority?: TicketPriority;
+    defaultAssignedGroupId?: string;
+    defaultSlaPolicyId?: string;
+    securityPolicyId?: string;
+    formRequirements?: ITicketFormRequirement[];
+    fieldDefinitionIds?: string[];
+    layoutIds?: string[];
+}
+export interface ITicketResolutionType extends ITicketAuditedEntity {
+    name: string;
+    description?: string;
+    enabled: boolean;
+    order: number;
+    formRequirements?: ITicketFormRequirement[];
+    fieldDefinitionIds?: string[];
+    layoutIds?: string[];
+}

package/dist/Tickets/Category.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/Tickets/Common.d.ts

@@ -0,0 +1,90 @@
+import { IContactInfo } from "../Contacts/contacts";
+export declare enum TicketStage {
+    NEW = "NEW",
+    ACTIVE = "ACTIVE",
+    RESOLVED = "RESOLVED",
+    CLOSED = "CLOSED",
+    CANCELLED = "CANCELLED"
+}
+export declare enum TicketPriority {
+    LOW = "LOW",
+    MEDIUM = "MEDIUM",
+    HIGH = "HIGH",
+    URGENT = "URGENT"
+}
+export declare enum TicketOrigin {
+    MANUAL = "MANUAL",
+    API = "API",
+    IMPORT = "IMPORT",
+    AUTOMATION = "AUTOMATION",
+    CONVERSATION = "CONVERSATION",
+    WEB_FORM = "WEB_FORM",
+    SOCIAL_MEDIA = "SOCIAL_MEDIA",
+    EMAIL = "EMAIL",
+    PHONE = "PHONE",
+    OTHER = "OTHER"
+}
+export declare enum TicketAccessLevel {
+    ALL = "ALL",
+    GROUP = "GROUP",
+    AGENT = "AGENT",
+    OWN = "OWN"
+}
+export type TicketPropertyPrimitive = string | number | boolean | Date | null;
+export type TicketPropertyValue = TicketPropertyPrimitive | TicketPropertyValue[] | {
+    [key: string]: TicketPropertyValue;
+};
+export interface ITicketProperty {
+    nameKey: string;
+    value: TicketPropertyValue;
+}
+export interface ITicketTagInfo {
+    id: string;
+    name: string;
+    color?: string;
+}
+export interface ITicketExternalReference {
+    system: string;
+    externalId: string;
+    externalUrl?: string;
+    lastSyncedAt?: Date;
+}
+export interface ITicketAttachment {
+    id: string;
+    spaceId: string;
+    ticketId: string;
+    fileName: string;
+    mimeType: string;
+    sizeBytes: number;
+    storageKey: string;
+    downloadUrl?: string;
+    checksum?: string;
+    createdAt: Date;
+    createdBy: string;
+    deletedAt?: Date;
+    deletedBy?: string;
+}
+export interface ITicketAuditedEntity {
+    id: string;
+    spaceId: string;
+    createdAt: Date;
+    createdBy: string;
+    updatedAt?: Date;
+    updatedBy?: string;
+    deletedAt?: Date;
+    deletedBy?: string;
+}
+export type ITicketContactProjection = IContactInfo;
+export interface ITicketDateRange {
+    from: Date;
+    to: Date;
+}
+export interface ITicketMetricPoint {
+    date: Date;
+    value: number;
+}
+export interface ITicketMetricGroup {
+    key: string;
+    label: string;
+    value: number;
+}

package/dist/Tickets/Common.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TicketAccessLevel = exports.TicketOrigin = exports.TicketPriority = exports.TicketStage = void 0;
+var TicketStage;
+(function (TicketStage) {
+    TicketStage["NEW"] = "NEW";
+    TicketStage["ACTIVE"] = "ACTIVE";
+    TicketStage["RESOLVED"] = "RESOLVED";
+    TicketStage["CLOSED"] = "CLOSED";
+    TicketStage["CANCELLED"] = "CANCELLED";
+})(TicketStage || (exports.TicketStage = TicketStage = {}));
+var TicketPriority;
+(function (TicketPriority) {
+    TicketPriority["LOW"] = "LOW";
+    TicketPriority["MEDIUM"] = "MEDIUM";
+    TicketPriority["HIGH"] = "HIGH";
+    TicketPriority["URGENT"] = "URGENT";
+})(TicketPriority || (exports.TicketPriority = TicketPriority = {}));
+var TicketOrigin;
+(function (TicketOrigin) {
+    TicketOrigin["MANUAL"] = "MANUAL";
+    TicketOrigin["API"] = "API";
+    TicketOrigin["IMPORT"] = "IMPORT";
+    TicketOrigin["AUTOMATION"] = "AUTOMATION";
+    TicketOrigin["CONVERSATION"] = "CONVERSATION";
+    TicketOrigin["WEB_FORM"] = "WEB_FORM";
+    TicketOrigin["SOCIAL_MEDIA"] = "SOCIAL_MEDIA";
+    TicketOrigin["EMAIL"] = "EMAIL";
+    TicketOrigin["PHONE"] = "PHONE";
+    TicketOrigin["OTHER"] = "OTHER";
+})(TicketOrigin || (exports.TicketOrigin = TicketOrigin = {}));
+var TicketAccessLevel;
+(function (TicketAccessLevel) {
+    TicketAccessLevel["ALL"] = "ALL";
+    TicketAccessLevel["GROUP"] = "GROUP";
+    TicketAccessLevel["AGENT"] = "AGENT";
+    TicketAccessLevel["OWN"] = "OWN";
+})(TicketAccessLevel || (exports.TicketAccessLevel = TicketAccessLevel = {}));