@voiceflow/dtos-interact 1.1.0

package/build/cjs/request/intent/intent-request.dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent-request.dto.d.ts","sourceRoot":"","sources":["../../../../src/request/intent/intent-request.dto.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,eAAe;;;;;;;;;;;;EAI1B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE3D,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAOnB,CAAC;AAEjB,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEzE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAMpB,CAAC;AAEjB,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE3E,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAGb,CAAC;AAEjB,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE7D,eAAO,MAAM,eAAe,UAAW,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAmB7C,CAAC"}

package/build/cjs/request/intent/intent-request.dto.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIntentRequest = exports.IntentRequestDTO = exports.IntentRequestPayloadDTO = exports.IntentRequestEntityDTO = exports.VerboseValueDTO = void 0;
+const zod_1 = require("zod");
+const payload_dto_1 = require("../payload.dto");
+const request_type_enum_1 = require("../request-type.enum");
+const utils_dto_1 = require("../utils.dto");
+exports.VerboseValueDTO = zod_1.z.object({
+    rawText: zod_1.z.string(),
+    canonicalText: zod_1.z.string(),
+    startIndex: zod_1.z.number(),
+});
+exports.IntentRequestEntityDTO = zod_1.z
+    .object({
+    name: zod_1.z.string(),
+    value: zod_1.z.string(),
+    query: zod_1.z.string().optional(),
+    verboseValue: zod_1.z.array(exports.VerboseValueDTO).optional(),
+})
+    .passthrough();
+exports.IntentRequestPayloadDTO = payload_dto_1.ActionAndLabelRequestPayloadDTO.extend({
+    data: zod_1.z.record(zod_1.z.any()).optional(),
+    query: zod_1.z.string().default(''),
+    entities: zod_1.z.array(exports.IntentRequestEntityDTO).default([]),
+    intent: zod_1.z.object({ name: zod_1.z.string() }).passthrough(),
+    confidence: zod_1.z.number().optional(),
+}).passthrough();
+exports.IntentRequestDTO = utils_dto_1.BaseRequestDTO.extend({
+    type: zod_1.z.literal(request_type_enum_1.RequestType.INTENT),
+    payload: exports.IntentRequestPayloadDTO,
+}).passthrough();
+const isIntentRequest = (value) => {
+    const parsedResult = exports.IntentRequestDTO.safeParse(value);
+    return (parsedResult.success &&
+        // Need to explicitly check that optional properties with default values exist before
+        // Zod transforms the input data. When Zod transforms data with a `.default()` tag
+        // it inserts the default value before validating that the value matches the type.
+        //
+        // This is problematic in use-cases where we use Zod purely as a type-guard, in which
+        // case, we discard the parsed object and instead use the original object which does
+        // not have default values injected, thus, creating a misleading type-guard.
+        !!value &&
+        typeof value === 'object' &&
+        'payload' in value &&
+        !!value.payload &&
+        typeof value.payload === 'object' &&
+        'entities' in value.payload &&
+        'query' in value.payload);
+};
+exports.isIntentRequest = isIntentRequest;
+//# sourceMappingURL=intent-request.dto.js.map

package/build/cjs/request/intent/intent-request.dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent-request.dto.js","sourceRoot":"","sources":["../../../../src/request/intent/intent-request.dto.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAExB,gDAAiE;AACjE,4DAAmD;AACnD,4CAA8C;AAEjC,QAAA,eAAe,GAAG,OAAC,CAAC,MAAM,CAAC;IACtC,OAAO,EAAE,OAAC,CAAC,MAAM,EAAE;IACnB,aAAa,EAAE,OAAC,CAAC,MAAM,EAAE;IACzB,UAAU,EAAE,OAAC,CAAC,MAAM,EAAE;CACvB,CAAC,CAAC;AAIU,QAAA,sBAAsB,GAAG,OAAC;KACpC,MAAM,CAAC;IACN,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE;IAChB,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE;IACjB,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC5B,YAAY,EAAE,OAAC,CAAC,KAAK,CAAC,uBAAe,CAAC,CAAC,QAAQ,EAAE;CAClD,CAAC;KACD,WAAW,EAAE,CAAC;AAIJ,QAAA,uBAAuB,GAAG,6CAA+B,CAAC,MAAM,CAAC;IAC5E,IAAI,EAAE,OAAC,CAAC,MAAM,CAAC,OAAC,CAAC,GAAG,EAAE,CAAC,CAAC,QAAQ,EAAE;IAClC,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC;IAC7B,QAAQ,EAAE,OAAC,CAAC,KAAK,CAAC,8BAAsB,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;IACrD,MAAM,EAAE,OAAC,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,WAAW,EAAE;IACpD,UAAU,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAClC,CAAC,CAAC,WAAW,EAAE,CAAC;AAIJ,QAAA,gBAAgB,GAAG,0BAAc,CAAC,MAAM,CAAC;IACpD,IAAI,EAAE,OAAC,CAAC,OAAO,CAAC,+BAAW,CAAC,MAAM,CAAC;IACnC,OAAO,EAAE,+BAAuB;CACjC,CAAC,CAAC,WAAW,EAAE,CAAC;AAIV,MAAM,eAAe,GAAG,CAAC,KAAc,EAA0B,EAAE;IACxE,MAAM,YAAY,GAAG,wBAAgB,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IACvD,OAAO,CACL,YAAY,CAAC,OAAO;QACpB,qFAAqF;QACrF,kFAAkF;QAClF,kFAAkF;QAClF,EAAE;QACF,qFAAqF;QACrF,oFAAoF;QACpF,4EAA4E;QAC5E,CAAC,CAAC,KAAK;QACP,OAAO,KAAK,KAAK,QAAQ;QACzB,SAAS,IAAI,KAAK;QAClB,CAAC,CAAC,KAAK,CAAC,OAAO;QACf,OAAO,KAAK,CAAC,OAAO,KAAK,QAAQ;QACjC,UAAU,IAAI,KAAK,CAAC,OAAO;QAC3B,OAAO,IAAI,KAAK,CAAC,OAAO,CACzB,CAAC;AACJ,CAAC,CAAC;AAnBW,QAAA,eAAe,mBAmB1B"}

package/build/cjs/request/launch-request.dto.d.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+export declare const LaunchRequestDTO: z.ZodObject<{
+    diagramID: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"launch">;
+    payload: z.ZodOptional<z.ZodObject<{
+        persona: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        persona: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        persona: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    diagramID: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"launch">;
+    payload: z.ZodOptional<z.ZodObject<{
+        persona: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        persona: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        persona: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    diagramID: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"launch">;
+    payload: z.ZodOptional<z.ZodObject<{
+        persona: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        persona: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        persona: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, z.ZodTypeAny, "passthrough">>;
+export type LaunchRequest = z.infer<typeof LaunchRequestDTO>;
+export declare const isLaunchRequest: (value: unknown) => value is z.objectOutputType<{
+    diagramID: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"launch">;
+    payload: z.ZodOptional<z.ZodObject<{
+        persona: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        persona: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        persona: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, z.ZodTypeAny, "passthrough">;
+//# sourceMappingURL=launch-request.dto.d.ts.map

package/build/cjs/request/launch-request.dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"launch-request.dto.d.ts","sourceRoot":"","sources":["../../../src/request/launch-request.dto.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAQb,CAAC;AAEjB,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE7D,eAAO,MAAM,eAAe,UAAW,OAAO;;;;;;;;;;+BAAsE,CAAC"}

package/build/cjs/request/launch-request.dto.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLaunchRequest = exports.LaunchRequestDTO = void 0;
+const zod_1 = require("zod");
+const request_type_enum_1 = require("./request-type.enum");
+const utils_dto_1 = require("./utils.dto");
+exports.LaunchRequestDTO = utils_dto_1.BaseRequestDTO.extend({
+    type: zod_1.z.literal(request_type_enum_1.RequestType.LAUNCH),
+    payload: zod_1.z
+        .object({
+        persona: zod_1.z.string().optional(),
+    })
+        .passthrough()
+        .optional(),
+}).passthrough();
+const isLaunchRequest = (value) => exports.LaunchRequestDTO.safeParse(value).success;
+exports.isLaunchRequest = isLaunchRequest;
+//# sourceMappingURL=launch-request.dto.js.map

package/build/cjs/request/launch-request.dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"launch-request.dto.js","sourceRoot":"","sources":["../../../src/request/launch-request.dto.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAExB,2DAAkD;AAClD,2CAA6C;AAEhC,QAAA,gBAAgB,GAAG,0BAAc,CAAC,MAAM,CAAC;IACpD,IAAI,EAAE,OAAC,CAAC,OAAO,CAAC,+BAAW,CAAC,MAAM,CAAC;IACnC,OAAO,EAAE,OAAC;SACP,MAAM,CAAC;QACN,OAAO,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;KAC/B,CAAC;SACD,WAAW,EAAE;SACb,QAAQ,EAAE;CACd,CAAC,CAAC,WAAW,EAAE,CAAC;AAIV,MAAM,eAAe,GAAG,CAAC,KAAc,EAA0B,EAAE,CAAC,wBAAgB,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC;AAAxG,QAAA,eAAe,mBAAyF"}

package/build/cjs/request/no-reply-request.dto.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export declare const NoReplyRequestDTO: z.ZodObject<{
+    diagramID: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"no-reply">;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    diagramID: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"no-reply">;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    diagramID: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"no-reply">;
+}, z.ZodTypeAny, "passthrough">>;
+export type NoReplyRequest = z.infer<typeof NoReplyRequestDTO>;
+export declare const isNoReplyRequest: (value: unknown) => value is z.objectOutputType<{
+    diagramID: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"no-reply">;
+}, z.ZodTypeAny, "passthrough">;
+//# sourceMappingURL=no-reply-request.dto.d.ts.map

package/build/cjs/request/no-reply-request.dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-reply-request.dto.d.ts","sourceRoot":"","sources":["../../../src/request/no-reply-request.dto.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,iBAAiB;;;;;;;;;gCAId,CAAC;AAEjB,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE/D,eAAO,MAAM,gBAAgB,UAAW,OAAO;;;+BAAwE,CAAC"}

package/build/cjs/request/no-reply-request.dto.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNoReplyRequest = exports.NoReplyRequestDTO = void 0;
+const zod_1 = require("zod");
+const request_type_enum_1 = require("./request-type.enum");
+const utils_dto_1 = require("./utils.dto");
+exports.NoReplyRequestDTO = utils_dto_1.BaseRequestDTO.omit({ payload: true })
+    .extend({
+    type: zod_1.z.literal(request_type_enum_1.RequestType.NO_REPLY),
+})
+    .passthrough();
+const isNoReplyRequest = (value) => exports.NoReplyRequestDTO.safeParse(value).success;
+exports.isNoReplyRequest = isNoReplyRequest;
+//# sourceMappingURL=no-reply-request.dto.js.map

package/build/cjs/request/no-reply-request.dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-reply-request.dto.js","sourceRoot":"","sources":["../../../src/request/no-reply-request.dto.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAExB,2DAAkD;AAClD,2CAA6C;AAEhC,QAAA,iBAAiB,GAAG,0BAAc,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;KACpE,MAAM,CAAC;IACN,IAAI,EAAE,OAAC,CAAC,OAAO,CAAC,+BAAW,CAAC,QAAQ,CAAC;CACtC,CAAC;KACD,WAAW,EAAE,CAAC;AAIV,MAAM,gBAAgB,GAAG,CAAC,KAAc,EAA2B,EAAE,CAAC,yBAAiB,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC;AAA3G,QAAA,gBAAgB,oBAA2F"}

package/build/cjs/request/payload.dto.d.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+export declare const ActionRequestPayloadDTO: z.ZodObject<{
+    actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        payload: z.ZodUnknown;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodString;
+        payload: z.ZodUnknown;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodString;
+        payload: z.ZodUnknown;
+    }, z.ZodTypeAny, "passthrough">>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    actions?: z.objectOutputType<{
+        type: z.ZodString;
+        payload: z.ZodUnknown;
+    }, z.ZodTypeAny, "passthrough">[] | undefined;
+}, {
+    actions?: z.objectInputType<{
+        type: z.ZodString;
+        payload: z.ZodUnknown;
+    }, z.ZodTypeAny, "passthrough">[] | undefined;
+}>;
+export type ActionRequestPayload = z.infer<typeof ActionRequestPayloadDTO>;
+export declare const LabelRequestPayloadDTO: z.ZodObject<{
+    label: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    label?: string | undefined;
+}, {
+    label?: string | undefined;
+}>;
+export type LabelRequestPayload = z.infer<typeof LabelRequestPayloadDTO>;
+export declare const ActionAndLabelRequestPayloadDTO: z.ZodObject<{
+    actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        payload: z.ZodUnknown;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        type: z.ZodString;
+        payload: z.ZodUnknown;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        type: z.ZodString;
+        payload: z.ZodUnknown;
+    }, z.ZodTypeAny, "passthrough">>, "many">>;
+    label: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    actions?: z.objectOutputType<{
+        type: z.ZodString;
+        payload: z.ZodUnknown;
+    }, z.ZodTypeAny, "passthrough">[] | undefined;
+    label?: string | undefined;
+}, {
+    actions?: z.objectInputType<{
+        type: z.ZodString;
+        payload: z.ZodUnknown;
+    }, z.ZodTypeAny, "passthrough">[] | undefined;
+    label?: string | undefined;
+}>;
+export type ActionAndLabelRequestPayload = z.infer<typeof ActionAndLabelRequestPayloadDTO>;
+//# sourceMappingURL=payload.dto.d.ts.map

package/build/cjs/request/payload.dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payload.dto.d.ts","sourceRoot":"","sources":["../../../src/request/payload.dto.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;EAElC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE3E,eAAO,MAAM,sBAAsB;;;;;;EAEjC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEzE,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;EAAwD,CAAC;AAErG,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC"}

package/build/cjs/request/payload.dto.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionAndLabelRequestPayloadDTO = exports.LabelRequestPayloadDTO = exports.ActionRequestPayloadDTO = void 0;
+const zod_1 = require("zod");
+const action_dto_1 = require("../action/action.dto");
+exports.ActionRequestPayloadDTO = zod_1.z.object({
+    actions: zod_1.z.array(action_dto_1.BaseActionDTO).optional(),
+});
+exports.LabelRequestPayloadDTO = zod_1.z.object({
+    label: zod_1.z.string().optional(),
+});
+exports.ActionAndLabelRequestPayloadDTO = exports.ActionRequestPayloadDTO.merge(exports.LabelRequestPayloadDTO);
+//# sourceMappingURL=payload.dto.js.map

package/build/cjs/request/payload.dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"payload.dto.js","sourceRoot":"","sources":["../../../src/request/payload.dto.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAExB,oDAAoD;AAEvC,QAAA,uBAAuB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC9C,OAAO,EAAE,OAAC,CAAC,KAAK,CAAC,0BAAa,CAAC,CAAC,QAAQ,EAAE;CAC3C,CAAC,CAAC;AAIU,QAAA,sBAAsB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC7C,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC7B,CAAC,CAAC;AAIU,QAAA,+BAA+B,GAAG,+BAAuB,CAAC,KAAK,CAAC,8BAAsB,CAAC,CAAC"}

package/build/cjs/request/request-config.dto.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export declare const RequestConfigDTO: z.ZodObject<{
+    tts: z.ZodOptional<z.ZodBoolean>;
+    stopAll: z.ZodOptional<z.ZodBoolean>;
+    stripSSML: z.ZodOptional<z.ZodBoolean>;
+    stopTypes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    selfDelegate: z.ZodOptional<z.ZodBoolean>;
+    excludeTypes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    tts?: boolean | undefined;
+    stopAll?: boolean | undefined;
+    stripSSML?: boolean | undefined;
+    stopTypes?: string[] | undefined;
+    selfDelegate?: boolean | undefined;
+    excludeTypes?: string[] | undefined;
+}, {
+    tts?: boolean | undefined;
+    stopAll?: boolean | undefined;
+    stripSSML?: boolean | undefined;
+    stopTypes?: string[] | undefined;
+    selfDelegate?: boolean | undefined;
+    excludeTypes?: string[] | undefined;
+}>;
+export type RequestConfig = z.infer<typeof RequestConfigDTO>;
+//# sourceMappingURL=request-config.dto.d.ts.map

package/build/cjs/request/request-config.dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-config.dto.d.ts","sourceRoot":"","sources":["../../../src/request/request-config.dto.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;EAO3B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/build/cjs/request/request-config.dto.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestConfigDTO = void 0;
+const zod_1 = require("zod");
+exports.RequestConfigDTO = zod_1.z.object({
+    tts: zod_1.z.boolean().optional(),
+    stopAll: zod_1.z.boolean().optional(),
+    stripSSML: zod_1.z.boolean().optional(),
+    stopTypes: zod_1.z.array(zod_1.z.string()).optional(),
+    selfDelegate: zod_1.z.boolean().optional(),
+    excludeTypes: zod_1.z.array(zod_1.z.string()).optional(),
+});
+//# sourceMappingURL=request-config.dto.js.map

package/build/cjs/request/request-config.dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-config.dto.js","sourceRoot":"","sources":["../../../src/request/request-config.dto.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAEX,QAAA,gBAAgB,GAAG,OAAC,CAAC,MAAM,CAAC;IACvC,GAAG,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;IAC3B,OAAO,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;IAC/B,SAAS,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;IACjC,SAAS,EAAE,OAAC,CAAC,KAAK,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;IACzC,YAAY,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;IACpC,YAAY,EAAE,OAAC,CAAC,KAAK,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;CAC7C,CAAC,CAAC"}

package/build/cjs/request/request-type.enum.d.ts

@@ -0,0 +1,10 @@
+export declare const RequestType: {
+    readonly TEXT: "text";
+    readonly ACTION: "action";
+    readonly INTENT: "intent";
+    readonly LAUNCH: "launch";
+    readonly NO_REPLY: "no-reply";
+    readonly EXIT_SCENARIO: "exit-scenario";
+};
+export type RequestType = (typeof RequestType)[keyof typeof RequestType];
+//# sourceMappingURL=request-type.enum.d.ts.map

package/build/cjs/request/request-type.enum.d.ts.map

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

package/build/cjs/request/request-type.enum.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestType = void 0;
+exports.RequestType = {
+    TEXT: 'text',
+    ACTION: 'action',
+    INTENT: 'intent',
+    LAUNCH: 'launch',
+    NO_REPLY: 'no-reply',
+    EXIT_SCENARIO: 'exit-scenario',
+};
+//# sourceMappingURL=request-type.enum.js.map

package/build/cjs/request/request-type.enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-type.enum.js","sourceRoot":"","sources":["../../../src/request/request-type.enum.ts"],"names":[],"mappings":";;;AAAa,QAAA,WAAW,GAAG;IACzB,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,QAAQ,EAAE,UAAU;IACpB,aAAa,EAAE,eAAe;CACtB,CAAC"}

package/build/cjs/request/text-request.dto.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export declare const TextRequestDTO: z.ZodObject<{
+    diagramID: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"text">;
+    payload: z.ZodString;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    diagramID: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"text">;
+    payload: z.ZodString;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    diagramID: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"text">;
+    payload: z.ZodString;
+}, z.ZodTypeAny, "passthrough">>;
+export type TextRequest = z.infer<typeof TextRequestDTO>;
+export declare const isTextRequest: (value: unknown) => value is z.objectOutputType<{
+    diagramID: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"text">;
+    payload: z.ZodString;
+}, z.ZodTypeAny, "passthrough">;
+//# sourceMappingURL=text-request.dto.d.ts.map

package/build/cjs/request/text-request.dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-request.dto.d.ts","sourceRoot":"","sources":["../../../src/request/text-request.dto.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,cAAc;;;;;;;;;;;;gCAGX,CAAC;AAEjB,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEzD,eAAO,MAAM,aAAa,UAAW,OAAO;;;;+BAAkE,CAAC"}

package/build/cjs/request/text-request.dto.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTextRequest = exports.TextRequestDTO = void 0;
+const zod_1 = require("zod");
+const request_type_enum_1 = require("./request-type.enum");
+const utils_dto_1 = require("./utils.dto");
+exports.TextRequestDTO = utils_dto_1.BaseRequestDTO.extend({
+    type: zod_1.z.literal(request_type_enum_1.RequestType.TEXT),
+    payload: zod_1.z.string(),
+}).passthrough();
+const isTextRequest = (value) => exports.TextRequestDTO.safeParse(value).success;
+exports.isTextRequest = isTextRequest;
+//# sourceMappingURL=text-request.dto.js.map

package/build/cjs/request/text-request.dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-request.dto.js","sourceRoot":"","sources":["../../../src/request/text-request.dto.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAExB,2DAAkD;AAClD,2CAA6C;AAEhC,QAAA,cAAc,GAAG,0BAAc,CAAC,MAAM,CAAC;IAClD,IAAI,EAAE,OAAC,CAAC,OAAO,CAAC,+BAAW,CAAC,IAAI,CAAC;IACjC,OAAO,EAAE,OAAC,CAAC,MAAM,EAAE;CACpB,CAAC,CAAC,WAAW,EAAE,CAAC;AAIV,MAAM,aAAa,GAAG,CAAC,KAAc,EAAwB,EAAE,CAAC,sBAAc,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC;AAAlG,QAAA,aAAa,iBAAqF"}

package/build/cjs/request/utils.dto.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export declare const BaseRequestDTO: 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;
+}>;
+export type BaseRequest = z.infer<typeof BaseRequestDTO>;
+//# sourceMappingURL=utils.dto.d.ts.map

package/build/cjs/request/utils.dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.dto.d.ts","sourceRoot":"","sources":["../../../src/request/utils.dto.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,cAAc;;;;;;;;;;;;EAIzB,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/build/cjs/request/utils.dto.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseRequestDTO = void 0;
+const zod_1 = require("zod");
+exports.BaseRequestDTO = zod_1.z.object({
+    type: zod_1.z.string(),
+    payload: zod_1.z.any().optional(), // payload can be string or object
+    diagramID: zod_1.z.string().optional(),
+});
+//# sourceMappingURL=utils.dto.js.map

package/build/cjs/request/utils.dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.dto.js","sourceRoot":"","sources":["../../../src/request/utils.dto.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAEX,QAAA,cAAc,GAAG,OAAC,CAAC,MAAM,CAAC;IACrC,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE;IAChB,OAAO,EAAE,OAAC,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,EAAE,kCAAkC;IAC/D,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CACjC,CAAC,CAAC"}

package/build/cjs/text/text.dto.d.ts

@@ -0,0 +1,4 @@
+import z from 'zod';
+export declare const SlateTextValueDTO: z.ZodAny;
+export type SlateTextValue = z.infer<typeof SlateTextValueDTO>;
+//# sourceMappingURL=text.dto.d.ts.map

package/build/cjs/text/text.dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.dto.d.ts","sourceRoot":"","sources":["../../../src/text/text.dto.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAGpB,eAAO,MAAM,iBAAiB,UAAU,CAAC;AAEzC,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/build/cjs/text/text.dto.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlateTextValueDTO = void 0;
+const zod_1 = __importDefault(require("zod"));
+// TODO: define and manage later
+exports.SlateTextValueDTO = zod_1.default.any();
+//# sourceMappingURL=text.dto.js.map

package/build/cjs/text/text.dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.dto.js","sourceRoot":"","sources":["../../../src/text/text.dto.ts"],"names":[],"mappings":";;;;;;AAAA,8CAAoB;AAEpB,gCAAgC;AACnB,QAAA,iBAAiB,GAAG,aAAC,CAAC,GAAG,EAAE,CAAC"}

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

@@ -0,0 +1,75 @@
+import { z } from 'zod';
+export declare const BlockTraceDTO: 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<"block">;
+    payload: z.ZodObject<{
+        blockID: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        blockID: string;
+    }, {
+        blockID: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "block";
+    payload: {
+        blockID: string;
+    };
+    paths?: {
+        label?: string | undefined;
+        event?: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+    defaultPath?: number | undefined;
+    time?: number | undefined;
+}, {
+    type: "block";
+    payload: {
+        blockID: string;
+    };
+    paths?: {
+        label?: string | undefined;
+        event?: {
+            type: string;
+            payload?: any;
+            diagramID?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+    defaultPath?: number | undefined;
+    time?: number | undefined;
+}>;
+export type BlockTrace = z.infer<typeof BlockTraceDTO>;
+//# sourceMappingURL=block.dto.d.ts.map

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"block.dto.js","sourceRoot":"","sources":["../../../src/trace/block.dto.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAExB,uDAA8C;AAC9C,2CAA2C;AAE9B,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,OAAO,EAAE,OAAC,CAAC,MAAM,EAAE;KACpB,CAAC;CACH,CAAC,CAAC"}