@voiceflow/dtos-interact 1.1.0

package/build/cjs/trace/entity-filling.dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-filling.dto.d.ts","sourceRoot":"","sources":["../../../src/trace/entity-filling.dto.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMhC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/build/cjs/trace/entity-filling.dto.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityFillingTraceDTO = void 0;
+const zod_1 = require("zod");
+const intent_request_dto_1 = require("../request/intent/intent-request.dto");
+const trace_type_enum_1 = require("./trace-type.enum");
+const utils_dto_1 = require("./utils.dto");
+exports.EntityFillingTraceDTO = utils_dto_1.BaseTraceDTO.extend({
+    type: zod_1.z.literal(trace_type_enum_1.TraceType.ENTITY_FILLING),
+    payload: zod_1.z.object({
+        entityToFill: zod_1.z.string(),
+        intent: intent_request_dto_1.IntentRequestDTO,
+    }),
+});
+//# sourceMappingURL=entity-filling.dto.js.map

package/build/cjs/trace/entity-filling.dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-filling.dto.js","sourceRoot":"","sources":["../../../src/trace/entity-filling.dto.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAExB,4EAAuE;AAEvE,uDAA8C;AAC9C,2CAA2C;AAE9B,QAAA,qBAAqB,GAAG,wBAAY,CAAC,MAAM,CAAC;IACvD,IAAI,EAAE,OAAC,CAAC,OAAO,CAAC,2BAAS,CAAC,cAAc,CAAC;IACzC,OAAO,EAAE,OAAC,CAAC,MAAM,CAAC;QAChB,YAAY,EAAE,OAAC,CAAC,MAAM,EAAE;QACxB,MAAM,EAAE,qCAAgB;KACzB,CAAC;CACH,CAAC,CAAC"}

package/build/cjs/trace/exit.dto.d.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+export declare const ExitTraceDTO: z.ZodObject<{
+    paths: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodOptional<z.ZodString>;
+        event: z.ZodOptional<z.ZodObject<{
+            type: z.ZodString;
+            payload: z.ZodOptional<z.ZodAny>;
+            diagramID: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        }, {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        label?: string | undefined;
+        event?: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        } | undefined;
+    }, {
+        label?: string | undefined;
+        event?: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        } | undefined;
+    }>, "many">>;
+    defaultPath: z.ZodOptional<z.ZodNumber>;
+    time: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"end">;
+}, "strip", z.ZodTypeAny, {
+    type: "end";
+    paths?: {
+        label?: string | undefined;
+        event?: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+    defaultPath?: number | undefined;
+    time?: number | undefined;
+}, {
+    type: "end";
+    paths?: {
+        label?: string | undefined;
+        event?: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+    defaultPath?: number | undefined;
+    time?: number | undefined;
+}>;
+export type ExitTrace = z.infer<typeof ExitTraceDTO>;
+//# sourceMappingURL=exit.dto.d.ts.map

package/build/cjs/trace/exit.dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exit.dto.d.ts","sourceRoot":"","sources":["../../../src/trace/exit.dto.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEvB,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/build/cjs/trace/exit.dto.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExitTraceDTO = void 0;
+const zod_1 = require("zod");
+const trace_type_enum_1 = require("./trace-type.enum");
+const utils_dto_1 = require("./utils.dto");
+exports.ExitTraceDTO = utils_dto_1.BaseTraceDTO.extend({
+    type: zod_1.z.literal(trace_type_enum_1.TraceType.END),
+});
+//# sourceMappingURL=exit.dto.js.map

package/build/cjs/trace/exit.dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exit.dto.js","sourceRoot":"","sources":["../../../src/trace/exit.dto.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAExB,uDAA8C;AAC9C,2CAA2C;AAE9B,QAAA,YAAY,GAAG,wBAAY,CAAC,MAAM,CAAC;IAC9C,IAAI,EAAE,OAAC,CAAC,OAAO,CAAC,2BAAS,CAAC,GAAG,CAAC;CAC/B,CAAC,CAAC"}

package/build/cjs/trace/flow.dto.d.ts

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+export declare const FlowTraceDTO: z.ZodObject<{
+    paths: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodOptional<z.ZodString>;
+        event: z.ZodOptional<z.ZodObject<{
+            type: z.ZodString;
+            payload: z.ZodOptional<z.ZodAny>;
+            diagramID: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        }, {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        label?: string | undefined;
+        event?: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        } | undefined;
+    }, {
+        label?: string | undefined;
+        event?: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        } | undefined;
+    }>, "many">>;
+    defaultPath: z.ZodOptional<z.ZodNumber>;
+    time: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"flow">;
+    payload: z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        diagramID: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        diagramID: string;
+        name?: string | undefined;
+    }, {
+        diagramID: string;
+        name?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "flow";
+    payload: {
+        diagramID: string;
+        name?: string | undefined;
+    };
+    paths?: {
+        label?: string | undefined;
+        event?: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+    defaultPath?: number | undefined;
+    time?: number | undefined;
+}, {
+    type: "flow";
+    payload: {
+        diagramID: string;
+        name?: string | undefined;
+    };
+    paths?: {
+        label?: string | undefined;
+        event?: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+    defaultPath?: number | undefined;
+    time?: number | undefined;
+}>;
+export type FlowTrace = z.infer<typeof FlowTraceDTO>;
+//# sourceMappingURL=flow.dto.d.ts.map

package/build/cjs/trace/flow.dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow.dto.d.ts","sourceRoot":"","sources":["../../../src/trace/flow.dto.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMvB,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/build/cjs/trace/flow.dto.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowTraceDTO = void 0;
+const zod_1 = require("zod");
+const trace_type_enum_1 = require("./trace-type.enum");
+const utils_dto_1 = require("./utils.dto");
+exports.FlowTraceDTO = utils_dto_1.BaseTraceDTO.extend({
+    type: zod_1.z.literal(trace_type_enum_1.TraceType.FLOW),
+    payload: zod_1.z.object({
+        name: zod_1.z.string().optional(),
+        diagramID: zod_1.z.string(),
+    }),
+});
+//# sourceMappingURL=flow.dto.js.map

package/build/cjs/trace/flow.dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow.dto.js","sourceRoot":"","sources":["../../../src/trace/flow.dto.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAExB,uDAA8C;AAC9C,2CAA2C;AAE9B,QAAA,YAAY,GAAG,wBAAY,CAAC,MAAM,CAAC;IAC9C,IAAI,EAAE,OAAC,CAAC,OAAO,CAAC,2BAAS,CAAC,IAAI,CAAC;IAC/B,OAAO,EAAE,OAAC,CAAC,MAAM,CAAC;QAChB,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAC3B,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE;KACtB,CAAC;CACH,CAAC,CAAC"}

package/build/cjs/trace/goto.dto.d.ts

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+export declare const GoToTraceDTO: z.ZodObject<{
+    paths: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodOptional<z.ZodString>;
+        event: z.ZodOptional<z.ZodObject<{
+            type: z.ZodString;
+            payload: z.ZodOptional<z.ZodAny>;
+            diagramID: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        }, {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        label?: string | undefined;
+        event?: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        } | undefined;
+    }, {
+        label?: string | undefined;
+        event?: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        } | undefined;
+    }>, "many">>;
+    defaultPath: z.ZodOptional<z.ZodNumber>;
+    time: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"goto">;
+    payload: z.ZodObject<{
+        request: z.ZodObject<{
+            type: z.ZodString;
+            payload: z.ZodOptional<z.ZodAny>;
+            diagramID: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        }, {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        request: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        };
+    }, {
+        request: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        };
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "goto";
+    payload: {
+        request: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        };
+    };
+    paths?: {
+        label?: string | undefined;
+        event?: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+    defaultPath?: number | undefined;
+    time?: number | undefined;
+}, {
+    type: "goto";
+    payload: {
+        request: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        };
+    };
+    paths?: {
+        label?: string | undefined;
+        event?: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+    defaultPath?: number | undefined;
+    time?: number | undefined;
+}>;
+export type GoToTrace = z.infer<typeof GoToTraceDTO>;
+//# sourceMappingURL=goto.dto.d.ts.map

package/build/cjs/trace/goto.dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"goto.dto.d.ts","sourceRoot":"","sources":["../../../src/trace/goto.dto.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKvB,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/build/cjs/trace/goto.dto.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoToTraceDTO = void 0;
+const zod_1 = require("zod");
+const utils_dto_1 = require("../request/utils.dto");
+const trace_type_enum_1 = require("./trace-type.enum");
+const utils_dto_2 = require("./utils.dto");
+exports.GoToTraceDTO = utils_dto_2.BaseTraceDTO.extend({
+    type: zod_1.z.literal(trace_type_enum_1.TraceType.GOTO),
+    payload: zod_1.z.object({
+        request: utils_dto_1.BaseRequestDTO,
+    }),
+});
+//# sourceMappingURL=goto.dto.js.map

package/build/cjs/trace/goto.dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"goto.dto.js","sourceRoot":"","sources":["../../../src/trace/goto.dto.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAExB,mDAAqD;AAErD,uDAA8C;AAC9C,2CAA2C;AAE9B,QAAA,YAAY,GAAG,wBAAY,CAAC,MAAM,CAAC;IAC9C,IAAI,EAAE,OAAC,CAAC,OAAO,CAAC,2BAAS,CAAC,IAAI,CAAC;IAC/B,OAAO,EAAE,OAAC,CAAC,MAAM,CAAC;QAChB,OAAO,EAAE,0BAAc;KACxB,CAAC;CACH,CAAC,CAAC"}

package/build/cjs/trace/log.dto.d.ts

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+export declare const LogTraceDTO: z.ZodObject<{
+    paths: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodOptional<z.ZodString>;
+        event: z.ZodOptional<z.ZodObject<{
+            type: z.ZodString;
+            payload: z.ZodOptional<z.ZodAny>;
+            diagramID: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        }, {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        label?: string | undefined;
+        event?: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        } | undefined;
+    }, {
+        label?: string | undefined;
+        event?: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        } | undefined;
+    }>, "many">>;
+    defaultPath: z.ZodOptional<z.ZodNumber>;
+    time: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"log">;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    type: "log";
+    payload: Record<string, unknown>;
+    paths?: {
+        label?: string | undefined;
+        event?: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+    defaultPath?: number | undefined;
+    time?: number | undefined;
+}, {
+    type: "log";
+    payload: Record<string, unknown>;
+    paths?: {
+        label?: string | undefined;
+        event?: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+    defaultPath?: number | undefined;
+    time?: number | undefined;
+}>;
+export type LogTrace = z.infer<typeof LogTraceDTO>;
+//# sourceMappingURL=log.dto.d.ts.map

package/build/cjs/trace/log.dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.dto.d.ts","sourceRoot":"","sources":["../../../src/trace/log.dto.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAItB,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC"}

package/build/cjs/trace/log.dto.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogTraceDTO = void 0;
+const zod_1 = require("zod");
+const trace_type_enum_1 = require("./trace-type.enum");
+const utils_dto_1 = require("./utils.dto");
+exports.LogTraceDTO = utils_dto_1.BaseTraceDTO.extend({
+    type: zod_1.z.literal(trace_type_enum_1.TraceType.LOG),
+    // TODO: define this later
+    payload: zod_1.z.record(zod_1.z.unknown()),
+});
+//# sourceMappingURL=log.dto.js.map

package/build/cjs/trace/log.dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.dto.js","sourceRoot":"","sources":["../../../src/trace/log.dto.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAExB,uDAA8C;AAC9C,2CAA2C;AAE9B,QAAA,WAAW,GAAG,wBAAY,CAAC,MAAM,CAAC;IAC7C,IAAI,EAAE,OAAC,CAAC,OAAO,CAAC,2BAAS,CAAC,GAAG,CAAC;IAC9B,0BAA0B;IAC1B,OAAO,EAAE,OAAC,CAAC,MAAM,CAAC,OAAC,CAAC,OAAO,EAAE,CAAC;CAC/B,CAAC,CAAC"}

package/build/cjs/trace/noreply.dto.d.ts

@@ -0,0 +1,75 @@
+import { z } from 'zod';
+export declare const NoReplyTraceDTO: z.ZodObject<{
+    paths: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodOptional<z.ZodString>;
+        event: z.ZodOptional<z.ZodObject<{
+            type: z.ZodString;
+            payload: z.ZodOptional<z.ZodAny>;
+            diagramID: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        }, {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        label?: string | undefined;
+        event?: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        } | undefined;
+    }, {
+        label?: string | undefined;
+        event?: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        } | undefined;
+    }>, "many">>;
+    defaultPath: z.ZodOptional<z.ZodNumber>;
+    time: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"no-reply">;
+    payload: z.ZodObject<{
+        timeout: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        timeout: number;
+    }, {
+        timeout: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "no-reply";
+    payload: {
+        timeout: number;
+    };
+    paths?: {
+        label?: string | undefined;
+        event?: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+    defaultPath?: number | undefined;
+    time?: number | undefined;
+}, {
+    type: "no-reply";
+    payload: {
+        timeout: number;
+    };
+    paths?: {
+        label?: string | undefined;
+        event?: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+    defaultPath?: number | undefined;
+    time?: number | undefined;
+}>;
+export type NoReplyTrace = z.infer<typeof NoReplyTraceDTO>;
+//# sourceMappingURL=noreply.dto.d.ts.map

package/build/cjs/trace/noreply.dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noreply.dto.d.ts","sourceRoot":"","sources":["../../../src/trace/noreply.dto.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK1B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/build/cjs/trace/noreply.dto.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoReplyTraceDTO = void 0;
+const zod_1 = require("zod");
+const trace_type_enum_1 = require("./trace-type.enum");
+const utils_dto_1 = require("./utils.dto");
+exports.NoReplyTraceDTO = utils_dto_1.BaseTraceDTO.extend({
+    type: zod_1.z.literal(trace_type_enum_1.TraceType.NO_REPLY),
+    payload: zod_1.z.object({
+        timeout: zod_1.z.number(),
+    }),
+});
+//# sourceMappingURL=noreply.dto.js.map

package/build/cjs/trace/noreply.dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"noreply.dto.js","sourceRoot":"","sources":["../../../src/trace/noreply.dto.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAExB,uDAA8C;AAC9C,2CAA2C;AAE9B,QAAA,eAAe,GAAG,wBAAY,CAAC,MAAM,CAAC;IACjD,IAAI,EAAE,OAAC,CAAC,OAAO,CAAC,2BAAS,CAAC,QAAQ,CAAC;IACnC,OAAO,EAAE,OAAC,CAAC,MAAM,CAAC;QAChB,OAAO,EAAE,OAAC,CAAC,MAAM,EAAE;KACpB,CAAC;CACH,CAAC,CAAC"}

package/build/cjs/trace/speak/speak.dto.d.ts

@@ -0,0 +1,93 @@
+import { z } from 'zod';
+export declare const SpeakTraceDTO: z.ZodObject<{
+    paths: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodOptional<z.ZodString>;
+        event: z.ZodOptional<z.ZodObject<{
+            type: z.ZodString;
+            payload: z.ZodOptional<z.ZodAny>;
+            diagramID: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        }, {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        label?: string | undefined;
+        event?: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        } | undefined;
+    }, {
+        label?: string | undefined;
+        event?: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        } | undefined;
+    }>, "many">>;
+    defaultPath: z.ZodOptional<z.ZodNumber>;
+    time: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"speak">;
+    payload: z.ZodObject<{
+        src: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        type: z.ZodNativeEnum<{
+            readonly AUDIO: "audio";
+            readonly MESSAGE: "message";
+        }>;
+        voice: z.ZodOptional<z.ZodString>;
+        isPrompt: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        type: "message" | "audio";
+        src?: string | null | undefined;
+        voice?: string | undefined;
+        isPrompt?: boolean | undefined;
+    }, {
+        type: "message" | "audio";
+        src?: string | null | undefined;
+        voice?: string | undefined;
+        isPrompt?: boolean | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "speak";
+    payload: {
+        type: "message" | "audio";
+        src?: string | null | undefined;
+        voice?: string | undefined;
+        isPrompt?: boolean | undefined;
+    };
+    paths?: {
+        label?: string | undefined;
+        event?: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+    defaultPath?: number | undefined;
+    time?: number | undefined;
+}, {
+    type: "speak";
+    payload: {
+        type: "message" | "audio";
+        src?: string | null | undefined;
+        voice?: string | undefined;
+        isPrompt?: boolean | undefined;
+    };
+    paths?: {
+        label?: string | undefined;
+        event?: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+    defaultPath?: number | undefined;
+    time?: number | undefined;
+}>;
+export type SpeakTrace = z.infer<typeof SpeakTraceDTO>;
+//# sourceMappingURL=speak.dto.d.ts.map

package/build/cjs/trace/speak/speak.dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"speak.dto.d.ts","sourceRoot":"","sources":["../../../../src/trace/speak/speak.dto.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQxB,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/build/cjs/trace/speak/speak.dto.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpeakTraceDTO = void 0;
+const zod_1 = require("zod");
+const trace_type_enum_1 = require("../trace-type.enum");
+const utils_dto_1 = require("../utils.dto");
+const trace_speak_type_enum_1 = require("./trace-speak-type.enum");
+exports.SpeakTraceDTO = utils_dto_1.BaseTraceDTO.extend({
+    type: zod_1.z.literal(trace_type_enum_1.TraceType.SPEAK),
+    payload: zod_1.z.object({
+        src: zod_1.z.string().nullable().optional(),
+        type: zod_1.z.nativeEnum(trace_speak_type_enum_1.TraceSpeakType),
+        voice: zod_1.z.string().optional(),
+        isPrompt: zod_1.z.boolean().optional(),
+    }),
+});
+//# sourceMappingURL=speak.dto.js.map

package/build/cjs/trace/speak/speak.dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"speak.dto.js","sourceRoot":"","sources":["../../../../src/trace/speak/speak.dto.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAExB,wDAA+C;AAC/C,4CAA4C;AAC5C,mEAAyD;AAE5C,QAAA,aAAa,GAAG,wBAAY,CAAC,MAAM,CAAC;IAC/C,IAAI,EAAE,OAAC,CAAC,OAAO,CAAC,2BAAS,CAAC,KAAK,CAAC;IAChC,OAAO,EAAE,OAAC,CAAC,MAAM,CAAC;QAChB,GAAG,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;QACrC,IAAI,EAAE,OAAC,CAAC,UAAU,CAAC,sCAAc,CAAC;QAClC,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAC5B,QAAQ,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;KACjC,CAAC;CACH,CAAC,CAAC"}

package/build/cjs/trace/speak/trace-speak-type.enum.d.ts

@@ -0,0 +1,6 @@
+export declare const TraceSpeakType: {
+    readonly AUDIO: "audio";
+    readonly MESSAGE: "message";
+};
+export type TraceSpeakType = (typeof TraceSpeakType)[keyof typeof TraceSpeakType];
+//# sourceMappingURL=trace-speak-type.enum.d.ts.map

package/build/cjs/trace/speak/trace-speak-type.enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-speak-type.enum.d.ts","sourceRoot":"","sources":["../../../../src/trace/speak/trace-speak-type.enum.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc;;;CAGjB,CAAC;AAEX,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,OAAO,cAAc,CAAC,CAAC"}

package/build/cjs/trace/speak/trace-speak-type.enum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraceSpeakType = void 0;
+exports.TraceSpeakType = {
+    AUDIO: 'audio',
+    MESSAGE: 'message',
+};
+//# sourceMappingURL=trace-speak-type.enum.js.map

package/build/cjs/trace/speak/trace-speak-type.enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-speak-type.enum.js","sourceRoot":"","sources":["../../../../src/trace/speak/trace-speak-type.enum.ts"],"names":[],"mappings":";;;AAAa,QAAA,cAAc,GAAG;IAC5B,KAAK,EAAE,OAAO;IACd,OAAO,EAAE,SAAS;CACV,CAAC"}