@trii/types 2.10.729 → 2.10.731

package/dist/Conversations/InboxCounters.js

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

package/dist/Conversations/index.d.ts

@@ -19,3 +19,4 @@ export * from './Queue';
 export * from './Routing';
 export * from './Sla';
 export * from './Transfer';
+export * from './Classifications';

package/dist/Conversations/index.js

@@ -58,3 +58,4 @@ __exportStar(require("./Queue"), exports);
 __exportStar(require("./Routing"), exports);
 __exportStar(require("./Sla"), exports);
 __exportStar(require("./Transfer"), exports);
+__exportStar(require("./Classifications"), exports);

package/dist/Presence/ChannelRoutingState.d.ts

@@ -0,0 +1,17 @@
+import { ChannelType } from "../Common/Channels/ChannelType";
+export interface ChannelRoutingState {
+    spaceId: string;
+    userId: string;
+    channelType: ChannelType;
+    isEligible: boolean;
+    presenceStatus: RoutingPresenceStatus;
+    activeJobCount: number;
+    maxCapacity: number;
+    notRespondingDetectedAt?: Date;
+    updatedAt: Date;
+}
+export declare enum RoutingPresenceStatus {
+    IDLE = 0,
+    INTERACTING = 1,
+    BUSY = 2
+}

package/dist/Presence/ChannelRoutingState.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoutingPresenceStatus = void 0;
+var RoutingPresenceStatus;
+(function (RoutingPresenceStatus) {
+    RoutingPresenceStatus[RoutingPresenceStatus["IDLE"] = 0] = "IDLE";
+    RoutingPresenceStatus[RoutingPresenceStatus["INTERACTING"] = 1] = "INTERACTING";
+    RoutingPresenceStatus[RoutingPresenceStatus["BUSY"] = 2] = "BUSY";
+})(RoutingPresenceStatus || (exports.RoutingPresenceStatus = RoutingPresenceStatus = {}));

package/dist/Tickets/AccessLevel.d.ts

@@ -0,0 +1,5 @@
+export declare enum TicketAccessLevel {
+    ALL = "ALL",
+    GROUP = "GROUP",
+    AGENT = "AGENT"
+}

package/dist/Tickets/AccessLevel.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TicketAccessLevel = void 0;
+var TicketAccessLevel;
+(function (TicketAccessLevel) {
+    TicketAccessLevel["ALL"] = "ALL";
+    TicketAccessLevel["GROUP"] = "GROUP";
+    TicketAccessLevel["AGENT"] = "AGENT";
+})(TicketAccessLevel || (exports.TicketAccessLevel = TicketAccessLevel = {}));

package/dist/Tickets/Common.d.ts

@@ -38,11 +38,73 @@ export interface ITicketProperty {
     nameKey: string;
     value: TicketPropertyValue;
 }
+/**
+ * Referencia liviana de una etiqueta tal como aparece embebida en un ticket
+ * (solo lo necesario para pintarla). El catálogo administrable usa ITicketTag.
+ */
 export interface ITicketTagInfo {
     id: string;
     name: string;
     color?: string;
 }
+/**
+ * Etiqueta administrable del catálogo. Shape propio (no extiende
+ * ITicketAuditedEntity a propósito): solo expone lo necesario para administrar
+ * el catálogo, sin `spaceId` ni autores (createdBy/updatedBy), que quedan
+ * internos al backend. Las fechas son opcionales porque una etiqueta recién
+ * creada aún no tiene `updatedAt`. La unicidad de nombre (con espacios
+ * normalizados e insensible a mayúsculas/minúsculas) es responsabilidad del
+ * backend, no del contrato.
+ */
+export interface ITicketTag {
+    id: string;
+    name: string;
+    color?: string;
+    description?: string;
+    enabled: boolean;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+export interface ICreateTicketTagDto {
+    name: string;
+    color?: string;
+    description?: string;
+}
+export interface IUpdateTicketTagDto {
+    name?: string;
+    color?: string | null;
+    description?: string | null;
+}
+/**
+ * Proyección de consulta: el catálogo con la cantidad de usos y la última
+ * utilización. No se persiste en la entidad; el backend la calcula por join
+ * sobre las asociaciones ticket↔etiqueta.
+ */
+export interface ITicketTagWithUsage extends ITicketTag {
+    usageCount?: number;
+    lastUsedAt?: Date;
+}
+/**
+ * Dependencias de una etiqueta: dónde se usa. Sirve para mostrar el impacto
+ * antes de desactivarla o eliminarla.
+ */
+export interface ITicketTagDependencies {
+    tagId: string;
+    tickets: number;
+    views: number;
+    automations: number;
+    macros: number;
+}
+/** Reemplaza/fusiona una etiqueta por otra: reasigna los usos y desactiva la fuente. */
+export interface IMergeTicketTagsDto {
+    sourceTagId: string;
+    targetTagId: string;
+}
+export interface IMergeTicketTagsResult {
+    targetTagId: string;
+    mergedSourceTagId: string;
+    reassignedUsages: number;
+}
 export interface ITicketExternalReference {
     system: string;
     externalId: string;

package/dist/Tickets/CustomerNotification.d.ts

@@ -0,0 +1,192 @@
+import type { ChannelType } from "../Common/Channels/ChannelType";
+import type { ITicketAuditedEntity } from "./Common";
+import type { TicketNotificationEvent } from "./SelfService";
+/**
+ * Ticket-relative recipient roles for CUSTOMER notifications only.
+ * Intentionally excludes any agent/internal-group role — this is the
+ * enforcement point that keeps internal recipients out of customer-facing
+ * notifications.
+ */
+export declare enum CustomerNotificationRecipientRole {
+    REQUESTER = "REQUESTER",
+    PARTICIPANT_CONTACTS = "PARTICIPANT_CONTACTS",
+    ACTION_ASSIGNEE = "ACTION_ASSIGNEE",
+    EXTERNAL_APPROVER = "EXTERNAL_APPROVER",
+    /** Members of the organization that have access to the ticket. */
+    ORGANIZATION_MEMBERS = "ORGANIZATION_MEMBERS",
+    /** Other external recipients defined by the domain/integration. */
+    OTHER_EXTERNAL_CONTACTS = "OTHER_EXTERNAL_CONTACTS"
+}
+/** Per event+channel+locale template selection. `templateId` points at a template SET id; `(channel, locale)` selects the VARIANT inside that set. */
+export interface ICustomerNotificationTemplateBinding {
+    channel: ChannelType;
+    locale: string;
+    templateId: string;
+}
+/** Granular flags describing what the CUSTOMER may do for this event. Mandatory events MUST keep `canDisable: false`. */
+export interface ICustomerNotificationEventCustomerPersonalization {
+    /** Customer may turn this event off entirely. */
+    canDisable: boolean;
+    /** Customer may pick which channels this event notifies them on. */
+    canChooseChannels: boolean;
+    /** Customer may mute this event for a single ticket. */
+    canMutePerTicket: boolean;
+    /** Customer may restore this event to the inherited/general values. */
+    canRestoreDefaults: boolean;
+}
+/** One configured `TicketNotificationEvent` inside a policy. */
+export interface ICustomerNotificationEventConfig {
+    event: TicketNotificationEvent;
+    enabled: boolean;
+    /** Mandatory events cannot be disabled or muted. */
+    mandatory: boolean;
+    customerPersonalization: ICustomerNotificationEventCustomerPersonalization;
+    recipients: CustomerNotificationRecipientRole[];
+    channels: ChannelType[];
+    /**
+     * Admin-chosen fallback channel used ONLY when the contact lacks the data
+     * required for the primary channel — per-event, explicit, NOT an automatic
+     * global fallback. `null` = no alternative; the resolver surfaces a WARNING
+     * instead of substituting silently.
+     */
+    alternativeChannel: ChannelType | null;
+    templates: ICustomerNotificationTemplateBinding[];
+}
+/**
+ * Space-general (`portalId: null`) or per-portal (`portalId: string`)
+ * customer notification policy. Persisted as a single row with `events` as a
+ * JSONB array.
+ */
+export interface ITicketCustomerNotificationPolicy extends ITicketAuditedEntity {
+    portalId: string | null;
+    enabled: boolean;
+    /** Policy display name. */
+    name?: string;
+    /** Policy display description. */
+    description?: string;
+    /**
+     * Policy-level master switch. When `false`, the resolver ignores the
+     * contact's `ITicketCustomerNotificationPreference` ENTIRELY for this
+     * policy — the general/portal policy's own decisions always apply,
+     * ticket-mute is never honored, and no event resolves with
+     * `origin: 'individual'`/`'muted'`. `true` (the column default) preserves
+     * default behavior.
+     */
+    respectIndividualPreferences: boolean;
+    defaultLocale: string;
+    fallbackLocale: string;
+    senderName?: string;
+    /**
+     * Opaque reference to a conversations-service email `IChannel.id`. Stored
+     * only; never resolved or validated against the conversations service.
+     * Kept as the EMAIL-only fallback for backward-compat — prefer
+     * `senderIdentityByChannel[EMAIL]` going forward.
+     */
+    senderIdentityId?: string;
+    /**
+     * Per-channel opaque sender-identity id override — a channel id (same
+     * `IChannel.id` reference as `senderIdentityId`) keyed by `ChannelType`.
+     */
+    senderIdentityByChannel?: Partial<Record<ChannelType, string>>;
+    replyToAddress?: string;
+    events: ICustomerNotificationEventConfig[];
+}
+/** HTML/TEXT content type. Numeric values mirror Marketing's shape by design. */
+export declare enum TemplateContentType {
+    HTML = 1,
+    TEXT = 2
+}
+/** Per-variant lifecycle status. `DISABLED` keeps the variant persisted while making the `DISABLED_TEMPLATE` warning fire for any event still referencing it. */
+export declare enum TemplateVariantStatus {
+    ENABLED = "ENABLED",
+    DISABLED = "DISABLED"
+}
+/**
+ * One channel+locale variant of a template set's content. `name` is an
+ * INTERNAL, admin-only label — never rendered to the customer. `signature` is
+ * per-variant free text.
+ */
+export interface ICustomerNotificationTemplateVariant {
+    channel: ChannelType;
+    locale: string;
+    /** Internal name, never shown to the customer. */
+    name: string;
+    subject?: string;
+    content: string;
+    signature?: string;
+    /** Variable keys (from the vetted catalog) referenced by this variant's content. */
+    allowedVariables: string[];
+    contentType: TemplateContentType;
+    status: TemplateVariantStatus;
+    version: number;
+}
+/** One template SET per `TicketNotificationEvent`, holding every channel+locale VARIANT for that event. */
+export interface ITicketCustomerNotificationTemplateSet extends ITicketAuditedEntity {
+    event: TicketNotificationEvent;
+    name: string;
+    variants: ICustomerNotificationTemplateVariant[];
+}
+export type ResolvedEventOrigin = "general" | "portal" | "individual" | "mandatory" | "muted";
+/**
+ * Channel-agnostic warning codes the resolver can determine structurally.
+ * A strict subset of any richer client-side diagnostic code set.
+ */
+export type ResolvedWarningCode = "EVENT_ACTIVE_WITHOUT_CHANNEL" | "EVENT_ACTIVE_WITHOUT_TEMPLATE" | "EVENT_ACTIVE_WITHOUT_RECIPIENTS" | "LANGUAGE_WITHOUT_TEMPLATE_OR_FALLBACK" | "INCOMPATIBLE_RECIPIENTS" | "MANDATORY_EVENT_ALLOWS_MUTE" | "PORTAL_DISABLED" | "DISABLED_TEMPLATE" | "INTERNAL_INFO_EXPOSING_VARIABLES" | "CUSTOMER_INVISIBLE_TEMPLATE_FIELDS";
+export interface IResolvedCustomerNotificationWarning {
+    code: ResolvedWarningCode;
+    /** Omitted for policy-level codes (currently only `PORTAL_DISABLED`). */
+    event?: TicketNotificationEvent;
+}
+export interface IResolvedCustomerNotificationEventConfig {
+    event: TicketNotificationEvent;
+    enabled: boolean;
+    mandatory: boolean;
+    customerPersonalization: ICustomerNotificationEventCustomerPersonalization;
+    origin: ResolvedEventOrigin;
+    recipients: CustomerNotificationRecipientRole[];
+    /** Channels actually used after `alternativeChannel` substitution (if any). */
+    channels: ChannelType[];
+    /** Channels requested by the policy/preference, before substitution. */
+    requestedChannels: ChannelType[];
+    senderIdentityByChannel: Partial<Record<ChannelType, string>>;
+    /** The admin-configured substitute channel (verbatim from the stored event). `null` = none. */
+    alternativeChannel: ChannelType | null;
+    alternativeChannelApplied: boolean;
+    warning?: string;
+    templates: ICustomerNotificationTemplateBinding[];
+    resolvedTemplate?: ICustomerNotificationTemplateBinding;
+}
+export interface IResolvedCustomerNotificationConfig {
+    spaceId: string;
+    portalId: string | null;
+    policyOrigin: "portal" | "general";
+    defaultLocale: string;
+    fallbackLocale: string;
+    senderName?: string;
+    senderIdentityId?: string;
+    senderIdentityByChannel?: Partial<Record<ChannelType, string>>;
+    replyToAddress?: string;
+    /** Whole-ticket mute flag (from the preference's muted ticket ids). */
+    muted: boolean;
+    events: IResolvedCustomerNotificationEventConfig[];
+    warnings: IResolvedCustomerNotificationWarning[];
+}
+type AuditedEntityKeys = keyof ITicketAuditedEntity;
+export type CreateCustomerNotificationPolicyDto = Omit<ITicketCustomerNotificationPolicy, AuditedEntityKeys | "enabled" | "respectIndividualPreferences"> & Partial<Pick<ITicketCustomerNotificationPolicy, "enabled" | "respectIndividualPreferences">>;
+/**
+ * The clearable optionals are nullable: `null` explicitly CLEARS the stored
+ * value on a PATCH while an omitted key leaves it untouched. Do NOT narrow
+ * these back to `string | undefined` — that would make it impossible to erase
+ * an already-saved sender/reply-to/name.
+ */
+export type UpdateCustomerNotificationPolicyDto = Partial<Omit<CreateCustomerNotificationPolicyDto, "name" | "description" | "senderName" | "senderIdentityId" | "senderIdentityByChannel" | "replyToAddress">> & {
+    name?: string | null;
+    description?: string | null;
+    senderName?: string | null;
+    senderIdentityId?: string | null;
+    senderIdentityByChannel?: Partial<Record<ChannelType, string>> | null;
+    replyToAddress?: string | null;
+};
+export type CreateCustomerNotificationTemplateSetDto = Omit<ITicketCustomerNotificationTemplateSet, AuditedEntityKeys>;
+export type UpdateCustomerNotificationTemplateSetDto = Partial<CreateCustomerNotificationTemplateSetDto>;
+export {};

package/dist/Tickets/CustomerNotification.js

@@ -0,0 +1,54 @@
+"use strict";
+// ---------------------------------------------------------------------------
+// Customer notification settings — policy, content templates and the resolved
+// effective-config contract.
+//
+// A policy is admin-configurable customer notification settings, either
+// space-general (`portalId: null`) or per-portal (`portalId: string`). It
+// combines with the pre-existing `ITicketCustomerNotificationPreference`
+// (the INDIVIDUAL contact-level exception overlay, see SelfService) at
+// resolution time; the resolved shape is `IResolvedCustomerNotificationConfig`
+// below.
+//
+// `TemplateContentType` intentionally mirrors Marketing's HTML/TEXT shape
+// (same numeric values) WITHOUT reusing Marketing's type — Tickets and
+// Marketing are separate bounded contexts and must not share a runtime
+// contract for this concern.
+// ---------------------------------------------------------------------------
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateVariantStatus = exports.TemplateContentType = exports.CustomerNotificationRecipientRole = void 0;
+// ---------------------------------------------------------------------------
+// Policy
+// ---------------------------------------------------------------------------
+/**
+ * Ticket-relative recipient roles for CUSTOMER notifications only.
+ * Intentionally excludes any agent/internal-group role — this is the
+ * enforcement point that keeps internal recipients out of customer-facing
+ * notifications.
+ */
+var CustomerNotificationRecipientRole;
+(function (CustomerNotificationRecipientRole) {
+    CustomerNotificationRecipientRole["REQUESTER"] = "REQUESTER";
+    CustomerNotificationRecipientRole["PARTICIPANT_CONTACTS"] = "PARTICIPANT_CONTACTS";
+    CustomerNotificationRecipientRole["ACTION_ASSIGNEE"] = "ACTION_ASSIGNEE";
+    CustomerNotificationRecipientRole["EXTERNAL_APPROVER"] = "EXTERNAL_APPROVER";
+    /** Members of the organization that have access to the ticket. */
+    CustomerNotificationRecipientRole["ORGANIZATION_MEMBERS"] = "ORGANIZATION_MEMBERS";
+    /** Other external recipients defined by the domain/integration. */
+    CustomerNotificationRecipientRole["OTHER_EXTERNAL_CONTACTS"] = "OTHER_EXTERNAL_CONTACTS";
+})(CustomerNotificationRecipientRole || (exports.CustomerNotificationRecipientRole = CustomerNotificationRecipientRole = {}));
+// ---------------------------------------------------------------------------
+// Content templates
+// ---------------------------------------------------------------------------
+/** HTML/TEXT content type. Numeric values mirror Marketing's shape by design. */
+var TemplateContentType;
+(function (TemplateContentType) {
+    TemplateContentType[TemplateContentType["HTML"] = 1] = "HTML";
+    TemplateContentType[TemplateContentType["TEXT"] = 2] = "TEXT";
+})(TemplateContentType || (exports.TemplateContentType = TemplateContentType = {}));
+/** Per-variant lifecycle status. `DISABLED` keeps the variant persisted while making the `DISABLED_TEMPLATE` warning fire for any event still referencing it. */
+var TemplateVariantStatus;
+(function (TemplateVariantStatus) {
+    TemplateVariantStatus["ENABLED"] = "ENABLED";
+    TemplateVariantStatus["DISABLED"] = "DISABLED";
+})(TemplateVariantStatus || (exports.TemplateVariantStatus = TemplateVariantStatus = {}));

package/dist/Tickets/Notes.d.ts

@@ -0,0 +1,13 @@
+import type { ITicketAuditedEntity } from "./Common";
+export interface ITicketNote extends ITicketAuditedEntity {
+    ticketId: string;
+    text: string;
+    version: number;
+}
+export interface CreateTicketNoteDto {
+    text: string;
+}
+export interface UpdateTicketNoteDto {
+    expectedVersion: number;
+    text: string;
+}

package/dist/Tickets/Notes.js

@@ -0,0 +1,10 @@
+"use strict";
+// ---------------------------------------------------------------------------
+// Ticket internal notes.
+//
+// Free-text internal annotations attached to a ticket, distinct from public
+// replies and from the conversation timeline. Optimistic concurrency via
+// version + expectedVersion on update, same pattern as the rest of the
+// module.
+// ---------------------------------------------------------------------------
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/Tickets/QuickResponse.d.ts

@@ -0,0 +1,64 @@
+import type { ITicketAuditedEntity } from "./Common";
+/** Whether the response is meant for a customer-visible reply, an internal note, or both. */
+export declare enum QuickResponseContentType {
+    PUBLIC = "PUBLIC",
+    INTERNAL = "INTERNAL",
+    BOTH = "BOTH"
+}
+/** Per-response lifecycle status. `DISABLED` keeps the response persisted and assigned to its category. */
+export declare enum QuickResponseStatus {
+    ENABLED = "ENABLED",
+    DISABLED = "DISABLED"
+}
+/**
+ * Fixed, closed list of supported content languages. Extending this list is a
+ * deliberate, versioned change — a caller cannot introduce an arbitrary
+ * locale.
+ */
+export declare enum LanguageCode {
+    ES = "ES",
+    EN = "EN",
+    PT = "PT"
+}
+/**
+ * Own category taxonomy for quick responses. A response count is intentionally
+ * NOT part of this interface: it is DERIVED (COUNT of active responses in the
+ * category) and never persisted.
+ */
+export interface ITicketQuickResponseCategory extends ITicketAuditedEntity {
+    name: string;
+    displayOrder: number;
+    enabled: boolean;
+}
+/**
+ * One prepared text. `applicableCategoryIds`/`applicableSubcategoryIds` point
+ * at real `ITicketCategory` rows. `roleIds`/`groupIds`/`userIds` express
+ * VISIBILITY only (discoverability), never extra ticket permissions. Empty
+ * visibility arrays mean "everyone".
+ */
+export interface ITicketQuickResponse extends ITicketAuditedEntity {
+    title: string;
+    description?: string;
+    categoryId: string;
+    content: string;
+    contentType: QuickResponseContentType;
+    language: LanguageCode;
+    /** Catalog variable keys referenced by `content` (e.g. `ticketNumber`, `customerName`). */
+    variablesUsed: string[];
+    applicableCategoryIds: string[];
+    applicableSubcategoryIds: string[];
+    applicableRequestTypeIds: string[];
+    applicablePortalIds: string[];
+    /** Agent-group scope dimension (mirrors `groupIds`/`roleIds`/`userIds`). */
+    applicableGroupIds: string[];
+    roleIds: string[];
+    groupIds: string[];
+    userIds: string[];
+    status: QuickResponseStatus;
+}
+type AuditKeys = keyof ITicketAuditedEntity;
+export type CreateTicketQuickResponseCategoryDto = Omit<ITicketQuickResponseCategory, AuditKeys>;
+export type UpdateTicketQuickResponseCategoryDto = Partial<CreateTicketQuickResponseCategoryDto>;
+export type CreateTicketQuickResponseDto = Omit<ITicketQuickResponse, AuditKeys>;
+export type UpdateTicketQuickResponseDto = Partial<CreateTicketQuickResponseDto>;
+export {};

package/dist/Tickets/QuickResponse.js

@@ -0,0 +1,41 @@
+"use strict";
+// ---------------------------------------------------------------------------
+// Ticket quick responses ("Respuestas rápidas").
+//
+// A Tickets-owned library of prepared texts that agents insert manually into a
+// public reply or an internal note. Fully independent from Conversaciones'
+// `IQuickResponse` — there is no cross-reference to Conversaciones in the
+// persisted schema.
+//
+// Category storage is a DEDICATED taxonomy (`ITicketQuickResponseCategory`),
+// NOT a reuse of `ITicketCategory`. `applicableCategoryIds` /
+// `applicableSubcategoryIds` are the only place this feature relates to
+// `ITicketCategory` (subcategories are child `ticket_categories` rows via
+// `parentId`, not a separate entity).
+// ---------------------------------------------------------------------------
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LanguageCode = exports.QuickResponseStatus = exports.QuickResponseContentType = void 0;
+/** Whether the response is meant for a customer-visible reply, an internal note, or both. */
+var QuickResponseContentType;
+(function (QuickResponseContentType) {
+    QuickResponseContentType["PUBLIC"] = "PUBLIC";
+    QuickResponseContentType["INTERNAL"] = "INTERNAL";
+    QuickResponseContentType["BOTH"] = "BOTH";
+})(QuickResponseContentType || (exports.QuickResponseContentType = QuickResponseContentType = {}));
+/** Per-response lifecycle status. `DISABLED` keeps the response persisted and assigned to its category. */
+var QuickResponseStatus;
+(function (QuickResponseStatus) {
+    QuickResponseStatus["ENABLED"] = "ENABLED";
+    QuickResponseStatus["DISABLED"] = "DISABLED";
+})(QuickResponseStatus || (exports.QuickResponseStatus = QuickResponseStatus = {}));
+/**
+ * Fixed, closed list of supported content languages. Extending this list is a
+ * deliberate, versioned change — a caller cannot introduce an arbitrary
+ * locale.
+ */
+var LanguageCode;
+(function (LanguageCode) {
+    LanguageCode["ES"] = "ES";
+    LanguageCode["EN"] = "EN";
+    LanguageCode["PT"] = "PT";
+})(LanguageCode || (exports.LanguageCode = LanguageCode = {}));

package/dist/Tickets/Task.d.ts

@@ -120,3 +120,14 @@ export interface IApplyTicketTaskTemplateDto {
     expectedTicketVersion: number;
     templateId: string;
 }
+export interface CreateTaskDependencyDto {
+    successorTaskId: string;
+    type: TicketTaskDependencyType;
+}
+export interface DeleteTicketTaskOptions {
+    expectedTaskVersion?: number;
+}
+export interface TicketTaskListResult {
+    tasks: ITicketTask[];
+    dependencies: ITicketTaskDependency[];
+}

package/dist/Tickets/Ticket.d.ts

@@ -39,6 +39,7 @@ export interface ITicket {
     externalReferences: ITicketExternalReference[];
     version: number;
     categoryId: string;
+    requestTypeId?: string;
     channelType?: ChannelType;
     channelId?: string;
     primaryConversationId?: string;
@@ -82,6 +83,7 @@ export interface ICreateTicketDto {
     source?: string;
     idempotencyKey?: string;
     categoryId: string;
+    requestTypeId?: string;
     channelType?: ChannelType;
     channelId?: string;
     primaryConversationId?: string;

package/dist/Tickets/index.d.ts

@@ -10,6 +10,9 @@ export * from './Conversation';
 export * from './Routing';
 export * from './Approval';
 export * from './Task';
+export * from './Notes';
+export * from './QuickResponse';
+export * from './CustomerNotification';
 export * from './SelfService';
 export * from './Security';
 export * from './AdvancedApi';

package/dist/Tickets/index.js

@@ -26,6 +26,9 @@ __exportStar(require("./Conversation"), exports);
 __exportStar(require("./Routing"), exports);
 __exportStar(require("./Approval"), exports);
 __exportStar(require("./Task"), exports);
+__exportStar(require("./Notes"), exports);
+__exportStar(require("./QuickResponse"), exports);
+__exportStar(require("./CustomerNotification"), exports);
 __exportStar(require("./SelfService"), exports);
 __exportStar(require("./Security"), exports);
 __exportStar(require("./AdvancedApi"), exports);

package/dist/src/Automations/Capabilities/Capability.d.ts

@@ -4,37 +4,6 @@ export declare enum AutomationCapabilityKind {
     ACTION = "action",
     CONDITION = "condition"
 }
-export declare enum AutomationCapabilityEffectClass {
-    NONE = "none",
-    READ = "read",
-    WRITE = "write",
-    COMMUNICATION = "communication",
-    BULK = "bulk"
-}
-export declare enum AutomationCapabilityIdempotency {
-    NONE = "none",
-    SUPPORTED = "supported",
-    REQUIRED = "required"
-}
-/** Capacidades operativas que el runtime puede aplicar de forma confiable. */
-export interface AutomationCapabilityExecutionSupport {
-    effectClass: AutomationCapabilityEffectClass;
-    supportsSimulation: boolean;
-    supportsTestTargets: boolean;
-    supportsUntilNode: boolean;
-    supportsFromNode: boolean;
-    supportsNodeOnly: boolean;
-    supportsCancellation: boolean;
-    idempotency: AutomationCapabilityIdempotency;
-    defaultTimeoutMs?: number | null;
-    maxAttempts?: number | null;
-    maxTestItems?: number | null;
-    inputSchema?: AutomationJsonSchema | null;
-    outputSchema?: AutomationJsonSchema | null;
-    simulationOutputSchema?: AutomationJsonSchema | null;
-    sensitivePaths?: string[] | null;
-    requiredPermissions?: string[] | null;
-}
 /**
  * Capacidad publicada por una aplicación de negocio para que Automation pueda
  * descubrirla y representarla sin incorporar reglas de ese dominio.
@@ -50,8 +19,6 @@ export interface AutomationCapability {
     requiredPermissions: string[];
     enabled: boolean;
     version: number;
-    /** Metadata opcional para definitions anteriores a la política de ejecución. */
-    executionSupport?: AutomationCapabilityExecutionSupport | null;
 }
 export interface AutomationCapabilityQuery {
     sourceApplications?: AutomationSourceApplication[];

package/dist/src/Automations/Capabilities/Capability.js

@@ -1,23 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AutomationCapabilityIdempotency = exports.AutomationCapabilityEffectClass = exports.AutomationCapabilityKind = void 0;
+exports.AutomationCapabilityKind = void 0;
 var AutomationCapabilityKind;
 (function (AutomationCapabilityKind) {
     AutomationCapabilityKind["TRIGGER"] = "trigger";
     AutomationCapabilityKind["ACTION"] = "action";
     AutomationCapabilityKind["CONDITION"] = "condition";
 })(AutomationCapabilityKind || (exports.AutomationCapabilityKind = AutomationCapabilityKind = {}));
-var AutomationCapabilityEffectClass;
-(function (AutomationCapabilityEffectClass) {
-    AutomationCapabilityEffectClass["NONE"] = "none";
-    AutomationCapabilityEffectClass["READ"] = "read";
-    AutomationCapabilityEffectClass["WRITE"] = "write";
-    AutomationCapabilityEffectClass["COMMUNICATION"] = "communication";
-    AutomationCapabilityEffectClass["BULK"] = "bulk";
-})(AutomationCapabilityEffectClass || (exports.AutomationCapabilityEffectClass = AutomationCapabilityEffectClass = {}));
-var AutomationCapabilityIdempotency;
-(function (AutomationCapabilityIdempotency) {
-    AutomationCapabilityIdempotency["NONE"] = "none";
-    AutomationCapabilityIdempotency["SUPPORTED"] = "supported";
-    AutomationCapabilityIdempotency["REQUIRED"] = "required";
-})(AutomationCapabilityIdempotency || (exports.AutomationCapabilityIdempotency = AutomationCapabilityIdempotency = {}));