wiil-core-js 0.0.82

package/dist/core/type-definitions/conversation.type.definition.js

@@ -0,0 +1,236 @@
+"use strict";
+/**
+ * @fileoverview Conversation type definitions and enumerations.
+ *
+ * Provides enumerations for conversation lifecycle management, event tracking,
+ * communication channels, and outbound messaging status tracking across
+ * telephony, email, and SMS channels.
+ *
+ * @module type-definitions/conversation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversationDirection = exports.OutboundTemplateChannel = exports.SmsStatus = exports.EmailStatus = exports.ScheduleType = exports.CallRequestStatus = exports.ConversationSummarySentiment = exports.TranslationDirection = exports.ConversationStatus = exports.ServiceConversationType = void 0;
+/**
+ * Service conversation channel types.
+ *
+ * Identifies the communication channel used for a conversation,
+ * enabling channel-specific handling and routing logic.
+ *
+ * @see ServiceConversationConfigSchema - Uses this for channel identification
+ */
+var ServiceConversationType;
+(function (ServiceConversationType) {
+    /** WebRTC or OTT voice call */
+    ServiceConversationType["OTT_CALL"] = "OTT_CALL";
+    /** WebRTC or OTT text chat */
+    ServiceConversationType["OTT_CHAT"] = "OTT_CHAT";
+    /** Traditional PSTN/SIP telephony call */
+    ServiceConversationType["TELEPHONY_CALL"] = "TELEPHONY_CALL";
+    /** SMS text messaging */
+    ServiceConversationType["SMS"] = "SMS";
+    /** Email communication */
+    ServiceConversationType["EMAIL"] = "EMAIL";
+    /** WhatsApp messaging */
+    ServiceConversationType["WHATSAPP"] = "WHATSAPP";
+    /** Telegram messaging */
+    ServiceConversationType["TELEGRAM"] = "TELEGRAM";
+})(ServiceConversationType || (exports.ServiceConversationType = ServiceConversationType = {}));
+/**
+ * Conversation lifecycle status.
+ *
+ * Tracks the current state of a conversation from initiation through
+ * completion and post-processing (summarization).
+ *
+ * @remarks
+ * **Status Flow:**
+ * ```
+ * PENDING → STARTED → ACTIVE → PAUSED → ACTIVE → ENDED → SUMMARIZED
+ * ```
+ *
+ * @see ServiceConversationConfigSchema - Uses this for lifecycle tracking
+ */
+var ConversationStatus;
+(function (ConversationStatus) {
+    /** Conversation created but not yet started */
+    ConversationStatus["PENDING"] = "pending";
+    /** Conversation initiated, awaiting participant connection */
+    ConversationStatus["STARTED"] = "started";
+    /** Conversation actively in progress with connected participants */
+    ConversationStatus["ACTIVE"] = "active";
+    /** Conversation temporarily paused (hold, transfer in progress) */
+    ConversationStatus["PAUSED"] = "paused";
+    /** Conversation ended, awaiting post-processing */
+    ConversationStatus["ENDED"] = "ended";
+    /** Initial AI summary generated for the conversation */
+    ConversationStatus["SUMMARIZED"] = "summarized";
+    /** Summary updated after additional processing or review */
+    ConversationStatus["UPDATED_SUMMARIZED"] = "updated_summarized";
+})(ConversationStatus || (exports.ConversationStatus = ConversationStatus = {}));
+/**
+ * Translation direction for multilingual conversations.
+ *
+ * Configures whether real-time translation applies in one or both directions
+ * during AI-assisted multilingual conversations.
+ */
+var TranslationDirection;
+(function (TranslationDirection) {
+    /** Translate both participant's speech to each other's language */
+    TranslationDirection["BIDIRECTIONAL"] = "bidirectional";
+    /** Translate only one participant's speech (typically agent to customer) */
+    TranslationDirection["UNIDIRECTIONAL"] = "unidirectional";
+})(TranslationDirection || (exports.TranslationDirection = TranslationDirection = {}));
+/**
+ * Conversation summary sentiment classification.
+ *
+ * AI-generated sentiment analysis result for conversation summaries,
+ * used for analytics, routing, and follow-up prioritization.
+ */
+var ConversationSummarySentiment;
+(function (ConversationSummarySentiment) {
+    /** Customer expressed satisfaction, issue resolved, or positive outcome */
+    ConversationSummarySentiment["POSITIVE"] = "positive";
+    /** Neutral interaction without strong positive or negative indicators */
+    ConversationSummarySentiment["NEUTRAL"] = "neutral";
+    /** Customer expressed frustration, issue unresolved, or negative outcome */
+    ConversationSummarySentiment["NEGATIVE"] = "negative";
+})(ConversationSummarySentiment || (exports.ConversationSummarySentiment = ConversationSummarySentiment = {}));
+/**
+ * Call request status for outbound call lifecycle tracking.
+ *
+ * Tracks the progression of an outbound call request from creation
+ * through execution and completion.
+ *
+ * @remarks
+ * **Status Lifecycle:**
+ * ```
+ * PENDING → SCHEDULED → IN_PROGRESS → COMPLETED
+ *                    ↘ FAILED
+ *        ↘ CANCELLED
+ * ```
+ *
+ * @see BusinessCallRequestSchema - Uses this for call tracking
+ */
+var CallRequestStatus;
+(function (CallRequestStatus) {
+    /** Call request created, awaiting processing or scheduled time */
+    CallRequestStatus["PENDING"] = "pending";
+    /** Call scheduled for future execution within calling hours */
+    CallRequestStatus["SCHEDULED"] = "scheduled";
+    /** Call currently active with AI agent engaged */
+    CallRequestStatus["IN_PROGRESS"] = "in_progress";
+    /** Call successfully completed with conversation recorded */
+    CallRequestStatus["COMPLETED"] = "completed";
+    /** Call failed due to technical error, no answer, or busy signal */
+    CallRequestStatus["FAILED"] = "failed";
+    /** Call cancelled before execution by user or system */
+    CallRequestStatus["CANCELLED"] = "cancelled";
+})(CallRequestStatus || (exports.CallRequestStatus = CallRequestStatus = {}));
+/**
+ * Schedule type for outbound call timing configuration.
+ *
+ * Determines when and how outbound calls are executed relative
+ * to the call request creation time.
+ *
+ * @see BusinessCallRequestSchema - Uses this for call scheduling
+ */
+var ScheduleType;
+(function (ScheduleType) {
+    /** Execute call as soon as possible within calling hours */
+    ScheduleType["IMMEDIATE"] = "immediate";
+    /** Execute call at specific scheduledAt timestamp */
+    ScheduleType["SCHEDULED"] = "scheduled";
+    /** Execute call on recurring schedule based on callingHours */
+    ScheduleType["RECURRING"] = "recurring";
+})(ScheduleType || (exports.ScheduleType = ScheduleType = {}));
+/**
+ * Email delivery status for tracking email lifecycle.
+ *
+ * Tracks the progression of an outbound email from queue through
+ * delivery or failure, updated by provider webhooks.
+ *
+ * @remarks
+ * **Status Lifecycle:**
+ * ```
+ * QUEUED → SENT → DELIVERED
+ *              ↘ BOUNCED
+ *              ↘ COMPLAINED
+ *       ↘ FAILED
+ * ```
+ *
+ * @see EmailRecordSchema - Uses this for delivery tracking
+ */
+var EmailStatus;
+(function (EmailStatus) {
+    /** Email request created, awaiting sending */
+    EmailStatus["QUEUED"] = "queued";
+    /** Email successfully submitted to mail provider */
+    EmailStatus["SENT"] = "sent";
+    /** Email confirmed delivered to recipient inbox */
+    EmailStatus["DELIVERED"] = "delivered";
+    /** Email bounced (hard or soft bounce from recipient server) */
+    EmailStatus["BOUNCED"] = "bounced";
+    /** Email failed to send due to technical error */
+    EmailStatus["FAILED"] = "failed";
+    /** Recipient marked email as spam (complaint received) */
+    EmailStatus["COMPLAINED"] = "complained";
+})(EmailStatus || (exports.EmailStatus = EmailStatus = {}));
+/**
+ * SMS delivery status for tracking message lifecycle.
+ *
+ * Tracks the progression of an outbound SMS from queue through
+ * delivery or failure, updated by carrier delivery reports.
+ *
+ * @remarks
+ * **Status Lifecycle:**
+ * ```
+ * QUEUED → SENT → DELIVERED
+ *              ↘ UNDELIVERED
+ *       ↘ FAILED
+ * ```
+ *
+ * @see SmsRequestSchema - Uses this for delivery tracking
+ */
+var SmsStatus;
+(function (SmsStatus) {
+    /** SMS request created, awaiting sending */
+    SmsStatus["QUEUED"] = "queued";
+    /** SMS successfully submitted to carrier */
+    SmsStatus["SENT"] = "sent";
+    /** SMS confirmed delivered to recipient device */
+    SmsStatus["DELIVERED"] = "delivered";
+    /** SMS failed to send due to technical error */
+    SmsStatus["FAILED"] = "failed";
+    /** SMS could not be delivered (invalid number, blocked, etc.) */
+    SmsStatus["UNDELIVERED"] = "undelivered";
+})(SmsStatus || (exports.SmsStatus = SmsStatus = {}));
+/**
+ * Outbound template channel types.
+ *
+ * Identifies the communication channel for outbound message templates.
+ *
+ * @see OutboundTemplateSchema - Uses this for channel identification
+ */
+var OutboundTemplateChannel;
+(function (OutboundTemplateChannel) {
+    /** Email template */
+    OutboundTemplateChannel["EMAIL"] = "EMAIL";
+    /** SMS text template */
+    OutboundTemplateChannel["SMS"] = "SMS";
+    /** WhatsApp message template */
+    OutboundTemplateChannel["WHATSAPP"] = "WHATSAPP";
+})(OutboundTemplateChannel || (exports.OutboundTemplateChannel = OutboundTemplateChannel = {}));
+/**
+ * Conversation direction for tracking inbound/outbound interactions.
+ *
+ * Identifies whether a conversation was initiated by the customer (inbound)
+ * or by the business (outbound) for analytics, routing, and billing purposes.
+ *
+ * @see ServiceConversationConfigSchema - Uses this for direction tracking
+ */
+var ConversationDirection;
+(function (ConversationDirection) {
+    /** Customer-initiated conversation (incoming call, received email, etc.) */
+    ConversationDirection["INBOUND"] = "inbound";
+    /** Business-initiated conversation (outbound call, campaign, etc.) */
+    ConversationDirection["OUTBOUND"] = "outbound";
+})(ConversationDirection || (exports.ConversationDirection = ConversationDirection = {}));

package/dist/core/type-definitions/display-order.d.ts

@@ -0,0 +1,154 @@
+import z from "zod";
+/**
+ * @fileoverview Display order schema definitions for managing item and category ordering.
+ * @module type-definitions/display-order
+ */
+/**
+ * Display order position mode enum.
+ */
+export declare const DisplayOrderPositionModeSchema: z.ZodEnum<{
+    BEGINNING: "BEGINNING";
+    END: "END";
+    KEEP_CURRENT: "KEEP_CURRENT";
+    BEFORE_ITEM: "BEFORE_ITEM";
+    AFTER_ITEM: "AFTER_ITEM";
+    ABSOLUTE_INDEX: "ABSOLUTE_INDEX";
+}>;
+/**
+ * Display order position intent schema.
+ */
+export declare const DisplayOrderPositionIntentSchema: z.ZodObject<{
+    mode: z.ZodEnum<{
+        BEGINNING: "BEGINNING";
+        END: "END";
+        KEEP_CURRENT: "KEEP_CURRENT";
+        BEFORE_ITEM: "BEFORE_ITEM";
+        AFTER_ITEM: "AFTER_ITEM";
+        ABSOLUTE_INDEX: "ABSOLUTE_INDEX";
+    }>;
+}, z.core.$strip>;
+/**
+ * Display order request schema for item positioning.
+ */
+export declare const DisplayOrderRequestSchema: z.ZodObject<{
+    itemId: z.ZodNullable<z.ZodString>;
+    targetCategoryId: z.ZodString;
+    positionIntent: z.ZodObject<{
+        mode: z.ZodEnum<{
+            BEGINNING: "BEGINNING";
+            END: "END";
+            KEEP_CURRENT: "KEEP_CURRENT";
+            BEFORE_ITEM: "BEFORE_ITEM";
+            AFTER_ITEM: "AFTER_ITEM";
+            ABSOLUTE_INDEX: "ABSOLUTE_INDEX";
+        }>;
+    }, z.core.$strip>;
+    anchorItemId: z.ZodNullable<z.ZodString>;
+    absoluteIndex: z.ZodNullable<z.ZodNumber>;
+    idempotencyKey: z.ZodUUID;
+    expectedVersion: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Display order response schema.
+ */
+export declare const DisplayOrderResponseSchema: z.ZodObject<{
+    itemId: z.ZodString;
+    targetCategoryId: z.ZodString;
+    resolvedDisplayOrder: z.ZodNumber;
+    resolvedPosition: z.ZodOptional<z.ZodNumber>;
+    categoryVersion: z.ZodNumber;
+    reindexed: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * Create display order placement schema for create-time positioning.
+ */
+export declare const CreateDisplayOrderPlacementSchema: z.ZodObject<{
+    placementIntent: z.ZodObject<{
+        mode: z.ZodEnum<{
+            BEGINNING: "BEGINNING";
+            END: "END";
+            KEEP_CURRENT: "KEEP_CURRENT";
+            BEFORE_ITEM: "BEFORE_ITEM";
+            AFTER_ITEM: "AFTER_ITEM";
+            ABSOLUTE_INDEX: "ABSOLUTE_INDEX";
+        }>;
+    }, z.core.$strip>;
+    anchorItemId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    absoluteIndex: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+/**
+ * Category display order request schema.
+ */
+export declare const CategoryDisplayOrderRequestSchema: z.ZodObject<{
+    categoryId: z.ZodString;
+    targetParentCategoryId: z.ZodNullable<z.ZodString>;
+    positionIntent: z.ZodObject<{
+        mode: z.ZodEnum<{
+            BEGINNING: "BEGINNING";
+            END: "END";
+            KEEP_CURRENT: "KEEP_CURRENT";
+            BEFORE_ITEM: "BEFORE_ITEM";
+            AFTER_ITEM: "AFTER_ITEM";
+            ABSOLUTE_INDEX: "ABSOLUTE_INDEX";
+        }>;
+    }, z.core.$strip>;
+    anchorCategoryId: z.ZodNullable<z.ZodString>;
+    absoluteIndex: z.ZodNullable<z.ZodNumber>;
+    idempotencyKey: z.ZodUUID;
+    expectedVersion: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Category display order response schema.
+ */
+export declare const CategoryDisplayOrderResponseSchema: z.ZodObject<{
+    categoryId: z.ZodString;
+    targetParentCategoryId: z.ZodNullable<z.ZodString>;
+    resolvedDisplayOrder: z.ZodNumber;
+    resolvedPosition: z.ZodOptional<z.ZodNumber>;
+    categoryVersion: z.ZodNumber;
+    reindexed: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * Category order entry schema for bulk ordering.
+ */
+export declare const CategoryOrderEntrySchema: z.ZodObject<{
+    categoryId: z.ZodString;
+    displayOrder: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Bulk category display orders request schema.
+ */
+export declare const CategoryDisplayOrdersRequestSchema: z.ZodObject<{
+    categoryOrders: z.ZodArray<z.ZodObject<{
+        categoryId: z.ZodString;
+        displayOrder: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Category item order entry schema.
+ */
+export declare const CategoryItemOrderEntrySchema: z.ZodObject<{
+    itemId: z.ZodString;
+    displayOrder: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Bulk category item display orders request schema.
+ */
+export declare const CategoryItemDisplayOrdersRequestSchema: z.ZodObject<{
+    categoryId: z.ZodString;
+    itemOrders: z.ZodArray<z.ZodObject<{
+        itemId: z.ZodString;
+        displayOrder: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type DisplayOrderPositionMode = z.infer<typeof DisplayOrderPositionModeSchema>;
+export type DisplayOrderPositionIntent = z.infer<typeof DisplayOrderPositionIntentSchema>;
+export type CreateDisplayOrderPlacement = z.infer<typeof CreateDisplayOrderPlacementSchema>;
+export type DisplayOrderRequest = z.infer<typeof DisplayOrderRequestSchema>;
+export type DisplayOrderResponse = z.infer<typeof DisplayOrderResponseSchema>;
+export type CategoryDisplayOrderRequest = z.infer<typeof CategoryDisplayOrderRequestSchema>;
+export type CategoryDisplayOrderResponse = z.infer<typeof CategoryDisplayOrderResponseSchema>;
+export type CategoryOrderEntry = z.infer<typeof CategoryOrderEntrySchema>;
+export type CategoryDisplayOrdersRequest = z.infer<typeof CategoryDisplayOrdersRequestSchema>;
+export type CategoryItemOrderEntry = z.infer<typeof CategoryItemOrderEntrySchema>;
+export type CategoryItemDisplayOrdersRequest = z.infer<typeof CategoryItemDisplayOrdersRequestSchema>;

package/dist/core/type-definitions/display-order.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CategoryItemDisplayOrdersRequestSchema = exports.CategoryItemOrderEntrySchema = exports.CategoryDisplayOrdersRequestSchema = exports.CategoryOrderEntrySchema = exports.CategoryDisplayOrderResponseSchema = exports.CategoryDisplayOrderRequestSchema = exports.CreateDisplayOrderPlacementSchema = exports.DisplayOrderResponseSchema = exports.DisplayOrderRequestSchema = exports.DisplayOrderPositionIntentSchema = exports.DisplayOrderPositionModeSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+/**
+ * @fileoverview Display order schema definitions for managing item and category ordering.
+ * @module type-definitions/display-order
+ */
+/**
+ * Display order position mode enum.
+ */
+exports.DisplayOrderPositionModeSchema = zod_1.default.enum([
+    "BEGINNING",
+    "END",
+    "KEEP_CURRENT",
+    "BEFORE_ITEM",
+    "AFTER_ITEM",
+    "ABSOLUTE_INDEX",
+]);
+/**
+ * Display order position intent schema.
+ */
+exports.DisplayOrderPositionIntentSchema = zod_1.default.object({
+    mode: exports.DisplayOrderPositionModeSchema.describe("Positioning mode for the item"),
+}).describe("How to place an entity in an ordered list");
+/**
+ * Validation helper for position intent.
+ */
+const applyPositionIntentValidation = (data, ctx, anchorValue, anchorPath) => {
+    const mode = data.positionIntent.mode;
+    const requiresAnchor = mode === "BEFORE_ITEM" || mode === "AFTER_ITEM";
+    const requiresAbsoluteIndex = mode === "ABSOLUTE_INDEX";
+    if (requiresAnchor && !anchorValue) {
+        ctx.addIssue({
+            code: "custom",
+            path: [anchorPath],
+            message: `${anchorPath} is required for BEFORE_ITEM and AFTER_ITEM`,
+        });
+    }
+    if (requiresAbsoluteIndex && data.absoluteIndex === null) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["absoluteIndex"],
+            message: "absoluteIndex is required for ABSOLUTE_INDEX",
+        });
+    }
+    if (!requiresAnchor && anchorValue !== null) {
+        ctx.addIssue({
+            code: "custom",
+            path: [anchorPath],
+            message: `${anchorPath} must be null unless mode is BEFORE_ITEM or AFTER_ITEM`,
+        });
+    }
+    if (!requiresAbsoluteIndex && data.absoluteIndex !== null) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["absoluteIndex"],
+            message: "absoluteIndex must be null unless mode is ABSOLUTE_INDEX",
+        });
+    }
+};
+/**
+ * Display order request schema for item positioning.
+ */
+exports.DisplayOrderRequestSchema = zod_1.default.object({
+    itemId: zod_1.default.string().nullable().describe("Target item identifier. Null when creating a new item"),
+    targetCategoryId: zod_1.default.string().min(1).describe("Category where ordering applies"),
+    positionIntent: exports.DisplayOrderPositionIntentSchema,
+    anchorItemId: zod_1.default.string().nullable().describe("Required for BEFORE_ITEM and AFTER_ITEM"),
+    absoluteIndex: zod_1.default.number().int().nonnegative().nullable().describe("Required for ABSOLUTE_INDEX (0-based)"),
+    idempotencyKey: zod_1.default.uuid().describe("Client-provided idempotency key (UUID v4)"),
+    expectedVersion: zod_1.default.number().int().nonnegative().describe("Optimistic concurrency version"),
+}).superRefine((data, ctx) => {
+    applyPositionIntentValidation(data, ctx, data.anchorItemId, "anchorItemId");
+}).describe("Configuration for display order of items in listings");
+/**
+ * Display order response schema.
+ */
+exports.DisplayOrderResponseSchema = zod_1.default.object({
+    itemId: zod_1.default.string().min(1).describe("Resolved item identifier"),
+    targetCategoryId: zod_1.default.string().min(1).describe("Category where the item is ordered"),
+    resolvedDisplayOrder: zod_1.default.number().int().nonnegative().describe("Persisted display order value"),
+    resolvedPosition: zod_1.default.number().int().positive().optional().describe("Optional 1-based position for UI"),
+    categoryVersion: zod_1.default.number().int().nonnegative().describe("Updated category version after reorder"),
+    reindexed: zod_1.default.boolean().describe("Whether sibling items were normalized/reindexed"),
+}).describe("Result of applying display order intent");
+/**
+ * Create display order placement schema for create-time positioning.
+ */
+exports.CreateDisplayOrderPlacementSchema = zod_1.default.object({
+    placementIntent: exports.DisplayOrderPositionIntentSchema,
+    anchorItemId: zod_1.default.string().nullable().optional().describe("Anchor item for relative positioning"),
+    absoluteIndex: zod_1.default.number().int().nonnegative().nullable().optional().describe("Absolute index for ABSOLUTE_INDEX mode"),
+}).superRefine((data, ctx) => {
+    applyPositionIntentValidation({
+        positionIntent: data.placementIntent,
+        absoluteIndex: data.absoluteIndex ?? null,
+    }, ctx, data.anchorItemId ?? null, "anchorItemId");
+}).describe("Optional create-time placement block for resolving displayOrder");
+/**
+ * Category display order request schema.
+ */
+exports.CategoryDisplayOrderRequestSchema = zod_1.default.object({
+    categoryId: zod_1.default.string().min(1).describe("Category to move"),
+    targetParentCategoryId: zod_1.default.string().nullable().describe("Target parent category. Null for root-level categories"),
+    positionIntent: exports.DisplayOrderPositionIntentSchema,
+    anchorCategoryId: zod_1.default.string().nullable().describe("Required for BEFORE_ITEM and AFTER_ITEM"),
+    absoluteIndex: zod_1.default.number().int().nonnegative().nullable().describe("Required for ABSOLUTE_INDEX (0-based)"),
+    idempotencyKey: zod_1.default.uuid().describe("Client-provided idempotency key (UUID v4)"),
+    expectedVersion: zod_1.default.number().int().nonnegative().describe("Optimistic concurrency version"),
+}).superRefine((data, ctx) => {
+    applyPositionIntentValidation(data, ctx, data.anchorCategoryId, "anchorCategoryId");
+}).describe("Configuration for reordering categories");
+/**
+ * Category display order response schema.
+ */
+exports.CategoryDisplayOrderResponseSchema = zod_1.default.object({
+    categoryId: zod_1.default.string().min(1).describe("Resolved category identifier"),
+    targetParentCategoryId: zod_1.default.string().nullable().describe("Resolved parent category. Null for root-level categories"),
+    resolvedDisplayOrder: zod_1.default.number().int().nonnegative().describe("Persisted display order value"),
+    resolvedPosition: zod_1.default.number().int().positive().optional().describe("Optional 1-based position for UI"),
+    categoryVersion: zod_1.default.number().int().nonnegative().describe("Updated category version after reorder"),
+    reindexed: zod_1.default.boolean().describe("Whether sibling categories were normalized/reindexed"),
+}).describe("Result of applying category order intent");
+/**
+ * Category order entry schema for bulk ordering.
+ */
+exports.CategoryOrderEntrySchema = zod_1.default.object({
+    categoryId: zod_1.default.string().min(1).describe("Category identifier"),
+    displayOrder: zod_1.default.number().int().nonnegative().describe("Target display order for the category"),
+});
+/**
+ * Bulk category display orders request schema.
+ */
+exports.CategoryDisplayOrdersRequestSchema = zod_1.default.object({
+    categoryOrders: zod_1.default.array(exports.CategoryOrderEntrySchema).min(1).describe("Ordered category display values"),
+});
+/**
+ * Category item order entry schema.
+ */
+exports.CategoryItemOrderEntrySchema = zod_1.default.object({
+    itemId: zod_1.default.string().min(1).describe("Item identifier"),
+    displayOrder: zod_1.default.number().int().nonnegative().describe("Target display order for the item"),
+});
+/**
+ * Bulk category item display orders request schema.
+ */
+exports.CategoryItemDisplayOrdersRequestSchema = zod_1.default.object({
+    categoryId: zod_1.default.string().min(1).describe("Category identifier"),
+    itemOrders: zod_1.default.array(exports.CategoryItemOrderEntrySchema).min(1).describe("Ordered item display values for the category"),
+});