import * as zod from 'zod';
import { z } from 'zod';

/**
 * Common reusable schemas and types
 */
declare const timestampSchema: z.ZodObject<{
    createdAt: z.ZodDate;
    updatedAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    createdAt: Date;
    updatedAt: Date;
}, {
    createdAt: Date;
    updatedAt: Date;
}>;
declare const paginationQuerySchema: z.ZodObject<{
    page: z.ZodDefault<z.ZodNumber>;
    limit: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    page: number;
    limit: number;
}, {
    page?: number | undefined;
    limit?: number | undefined;
}>;
declare const paginationResponseSchema: z.ZodObject<{
    page: z.ZodNumber;
    limit: z.ZodNumber;
    total: z.ZodNumber;
    totalPages: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    page: number;
    limit: number;
    total: number;
    totalPages: number;
}, {
    page: number;
    limit: number;
    total: number;
    totalPages: number;
}>;
declare const uuidSchema: z.ZodString;
declare const errorResponseSchema: z.ZodObject<{
    message: z.ZodString;
    code: z.ZodOptional<z.ZodString>;
    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    message: string;
    code?: string | undefined;
    details?: Record<string, unknown> | undefined;
}, {
    message: string;
    code?: string | undefined;
    details?: Record<string, unknown> | undefined;
}>;
declare const validationErrorResponseSchema: z.ZodObject<{
    message: z.ZodString;
    errors: z.ZodArray<z.ZodObject<{
        field: z.ZodString;
        message: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        message: string;
        field: string;
    }, {
        message: string;
        field: string;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    message: string;
    errors: {
        message: string;
        field: string;
    }[];
}, {
    message: string;
    errors: {
        message: string;
        field: string;
    }[];
}>;
declare const successResponseSchema: z.ZodObject<{
    message: z.ZodString;
}, "strip", z.ZodTypeAny, {
    message: string;
}, {
    message: string;
}>;
type TimestampFields = z.infer<typeof timestampSchema>;
type PaginationQuery = z.infer<typeof paginationQuerySchema>;
type PaginationResponse = z.infer<typeof paginationResponseSchema>;
type ErrorResponse = z.infer<typeof errorResponseSchema>;
type ValidationErrorResponse = z.infer<typeof validationErrorResponseSchema>;
type SuccessResponse = z.infer<typeof successResponseSchema>;

/**
 * Authentication & Authorization Schemas
 */
declare const loginSchema: z.ZodObject<{
    email: z.ZodString;
    password: z.ZodString;
}, "strip", z.ZodTypeAny, {
    email: string;
    password: string;
}, {
    email: string;
    password: string;
}>;
declare const loginResponseSchema: z.ZodObject<{
    accessToken: z.ZodString;
    refreshToken: z.ZodString;
    expiresIn: z.ZodNumber;
    user: z.ZodObject<{
        id: z.ZodString;
        email: z.ZodString;
        name: z.ZodString;
        role: z.ZodEnum<["admin", "agent", "viewer"]>;
        organizationId: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        email: string;
        id: string;
        name: string;
        role: "admin" | "agent" | "viewer";
        organizationId: string;
    }, {
        email: string;
        id: string;
        name: string;
        role: "admin" | "agent" | "viewer";
        organizationId: string;
    }>;
}, "strip", z.ZodTypeAny, {
    accessToken: string;
    refreshToken: string;
    expiresIn: number;
    user: {
        email: string;
        id: string;
        name: string;
        role: "admin" | "agent" | "viewer";
        organizationId: string;
    };
}, {
    accessToken: string;
    refreshToken: string;
    expiresIn: number;
    user: {
        email: string;
        id: string;
        name: string;
        role: "admin" | "agent" | "viewer";
        organizationId: string;
    };
}>;
declare const registerSchema: z.ZodObject<{
    email: z.ZodString;
    password: z.ZodString;
    name: z.ZodString;
    organizationName: z.ZodString;
}, "strip", z.ZodTypeAny, {
    email: string;
    password: string;
    name: string;
    organizationName: string;
}, {
    email: string;
    password: string;
    name: string;
    organizationName: string;
}>;
declare const registerResponseSchema: z.ZodObject<{
    accessToken: z.ZodString;
    refreshToken: z.ZodString;
    expiresIn: z.ZodNumber;
    user: z.ZodObject<{
        id: z.ZodString;
        email: z.ZodString;
        name: z.ZodString;
        role: z.ZodEnum<["admin", "agent", "viewer"]>;
        organizationId: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        email: string;
        id: string;
        name: string;
        role: "admin" | "agent" | "viewer";
        organizationId: string;
    }, {
        email: string;
        id: string;
        name: string;
        role: "admin" | "agent" | "viewer";
        organizationId: string;
    }>;
}, "strip", z.ZodTypeAny, {
    accessToken: string;
    refreshToken: string;
    expiresIn: number;
    user: {
        email: string;
        id: string;
        name: string;
        role: "admin" | "agent" | "viewer";
        organizationId: string;
    };
}, {
    accessToken: string;
    refreshToken: string;
    expiresIn: number;
    user: {
        email: string;
        id: string;
        name: string;
        role: "admin" | "agent" | "viewer";
        organizationId: string;
    };
}>;
declare const refreshTokenSchema: z.ZodObject<{
    refreshToken: z.ZodString;
}, "strip", z.ZodTypeAny, {
    refreshToken: string;
}, {
    refreshToken: string;
}>;
declare const refreshTokenResponseSchema: z.ZodObject<{
    accessToken: z.ZodString;
    expiresIn: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    accessToken: string;
    expiresIn: number;
}, {
    accessToken: string;
    expiresIn: number;
}>;
declare const createApiKeySchema: z.ZodObject<{
    name: z.ZodString;
    permissions: z.ZodArray<z.ZodString, "many">;
    expiresAt: z.ZodOptional<z.ZodDate>;
}, "strip", z.ZodTypeAny, {
    name: string;
    permissions: string[];
    expiresAt?: Date | undefined;
}, {
    name: string;
    permissions: string[];
    expiresAt?: Date | undefined;
}>;
declare const apiKeyResponseSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    key: z.ZodString;
    keyPrefix: z.ZodString;
    permissions: z.ZodArray<z.ZodString, "many">;
    expiresAt: z.ZodNullable<z.ZodDate>;
    lastUsedAt: z.ZodNullable<z.ZodDate>;
} & {
    createdAt: z.ZodDate;
    updatedAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    id: string;
    name: string;
    permissions: string[];
    expiresAt: Date | null;
    key: string;
    keyPrefix: string;
    lastUsedAt: Date | null;
    createdAt: Date;
    updatedAt: Date;
}, {
    id: string;
    name: string;
    permissions: string[];
    expiresAt: Date | null;
    key: string;
    keyPrefix: string;
    lastUsedAt: Date | null;
    createdAt: Date;
    updatedAt: Date;
}>;
declare const apiKeyListItemSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    keyPrefix: z.ZodString;
    permissions: z.ZodArray<z.ZodString, "many">;
    expiresAt: z.ZodNullable<z.ZodDate>;
    lastUsedAt: z.ZodNullable<z.ZodDate>;
} & {
    createdAt: z.ZodDate;
    updatedAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    id: string;
    name: string;
    permissions: string[];
    expiresAt: Date | null;
    keyPrefix: string;
    lastUsedAt: Date | null;
    createdAt: Date;
    updatedAt: Date;
}, {
    id: string;
    name: string;
    permissions: string[];
    expiresAt: Date | null;
    keyPrefix: string;
    lastUsedAt: Date | null;
    createdAt: Date;
    updatedAt: Date;
}>;
declare const changePasswordSchema: z.ZodObject<{
    currentPassword: z.ZodString;
    newPassword: z.ZodString;
}, "strip", z.ZodTypeAny, {
    currentPassword: string;
    newPassword: string;
}, {
    currentPassword: string;
    newPassword: string;
}>;
type LoginInput = z.infer<typeof loginSchema>;
type LoginResponse = z.infer<typeof loginResponseSchema>;
type RegisterInput = z.infer<typeof registerSchema>;
type RegisterResponse = z.infer<typeof registerResponseSchema>;
type RefreshTokenInput = z.infer<typeof refreshTokenSchema>;
type RefreshTokenResponse = z.infer<typeof refreshTokenResponseSchema>;
type CreateApiKeyInput = z.infer<typeof createApiKeySchema>;
type ApiKeyResponse = z.infer<typeof apiKeyResponseSchema>;
type ApiKeyListItem = z.infer<typeof apiKeyListItemSchema>;
type ChangePasswordInput = z.infer<typeof changePasswordSchema>;

/**
 * User Management Schemas
 */
declare const userSchema: z.ZodObject<{
    id: z.ZodString;
    email: z.ZodString;
    name: z.ZodString;
    role: z.ZodEnum<["admin", "agent", "viewer"]>;
    status: z.ZodEnum<["active", "invited", "suspended"]>;
    lastActiveAt: z.ZodNullable<z.ZodDate>;
    organizationId: z.ZodString;
} & {
    createdAt: z.ZodDate;
    updatedAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    status: "active" | "invited" | "suspended";
    email: string;
    id: string;
    name: string;
    role: "admin" | "agent" | "viewer";
    organizationId: string;
    createdAt: Date;
    updatedAt: Date;
    lastActiveAt: Date | null;
}, {
    status: "active" | "invited" | "suspended";
    email: string;
    id: string;
    name: string;
    role: "admin" | "agent" | "viewer";
    organizationId: string;
    createdAt: Date;
    updatedAt: Date;
    lastActiveAt: Date | null;
}>;
declare const createUserSchema: z.ZodObject<{
    email: z.ZodString;
    name: z.ZodString;
    role: z.ZodDefault<z.ZodEnum<["admin", "agent", "viewer"]>>;
    password: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    email: string;
    name: string;
    role: "admin" | "agent" | "viewer";
    password?: string | undefined;
}, {
    email: string;
    name: string;
    password?: string | undefined;
    role?: "admin" | "agent" | "viewer" | undefined;
}>;
declare const updateUserSchema: z.ZodObject<{
    name: z.ZodOptional<z.ZodString>;
    role: z.ZodOptional<z.ZodEnum<["admin", "agent", "viewer"]>>;
    status: z.ZodOptional<z.ZodEnum<["active", "invited", "suspended"]>>;
}, "strip", z.ZodTypeAny, {
    status?: "active" | "invited" | "suspended" | undefined;
    name?: string | undefined;
    role?: "admin" | "agent" | "viewer" | undefined;
}, {
    status?: "active" | "invited" | "suspended" | undefined;
    name?: string | undefined;
    role?: "admin" | "agent" | "viewer" | undefined;
}>;
declare const userListResponseSchema: z.ZodObject<{
    users: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        email: z.ZodString;
        name: z.ZodString;
        role: z.ZodEnum<["admin", "agent", "viewer"]>;
        status: z.ZodEnum<["active", "invited", "suspended"]>;
        lastActiveAt: z.ZodNullable<z.ZodDate>;
        organizationId: z.ZodString;
    } & {
        createdAt: z.ZodDate;
        updatedAt: z.ZodDate;
    }, "strip", z.ZodTypeAny, {
        status: "active" | "invited" | "suspended";
        email: string;
        id: string;
        name: string;
        role: "admin" | "agent" | "viewer";
        organizationId: string;
        createdAt: Date;
        updatedAt: Date;
        lastActiveAt: Date | null;
    }, {
        status: "active" | "invited" | "suspended";
        email: string;
        id: string;
        name: string;
        role: "admin" | "agent" | "viewer";
        organizationId: string;
        createdAt: Date;
        updatedAt: Date;
        lastActiveAt: Date | null;
    }>, "many">;
    pagination: z.ZodObject<{
        page: z.ZodNumber;
        limit: z.ZodNumber;
        total: z.ZodNumber;
        totalPages: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        page: number;
        limit: number;
        total: number;
        totalPages: number;
    }, {
        page: number;
        limit: number;
        total: number;
        totalPages: number;
    }>;
}, "strip", z.ZodTypeAny, {
    pagination: {
        page: number;
        limit: number;
        total: number;
        totalPages: number;
    };
    users: {
        status: "active" | "invited" | "suspended";
        email: string;
        id: string;
        name: string;
        role: "admin" | "agent" | "viewer";
        organizationId: string;
        createdAt: Date;
        updatedAt: Date;
        lastActiveAt: Date | null;
    }[];
}, {
    pagination: {
        page: number;
        limit: number;
        total: number;
        totalPages: number;
    };
    users: {
        status: "active" | "invited" | "suspended";
        email: string;
        id: string;
        name: string;
        role: "admin" | "agent" | "viewer";
        organizationId: string;
        createdAt: Date;
        updatedAt: Date;
        lastActiveAt: Date | null;
    }[];
}>;
type User = z.infer<typeof userSchema>;
type CreateUserInput = z.infer<typeof createUserSchema>;
type UpdateUserInput = z.infer<typeof updateUserSchema>;
type UserListResponse = z.infer<typeof userListResponseSchema>;

/**
 * Organization Management Schemas
 */
declare const organizationSchema: z.ZodObject<{
    id: z.ZodString;
    name: z.ZodString;
    slug: z.ZodString;
    plan: z.ZodEnum<["starter", "growth", "professional", "enterprise"]>;
    status: z.ZodEnum<["active", "suspended", "cancelled"]>;
} & {
    createdAt: z.ZodDate;
    updatedAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    status: "active" | "suspended" | "cancelled";
    id: string;
    name: string;
    createdAt: Date;
    updatedAt: Date;
    slug: string;
    plan: "starter" | "growth" | "professional" | "enterprise";
}, {
    status: "active" | "suspended" | "cancelled";
    id: string;
    name: string;
    createdAt: Date;
    updatedAt: Date;
    slug: string;
    plan: "starter" | "growth" | "professional" | "enterprise";
}>;
declare const createOrganizationSchema: z.ZodObject<{
    name: z.ZodString;
    slug: z.ZodString;
}, "strip", z.ZodTypeAny, {
    name: string;
    slug: string;
}, {
    name: string;
    slug: string;
}>;
declare const updateOrganizationSchema: z.ZodObject<{
    name: z.ZodOptional<z.ZodString>;
    plan: z.ZodOptional<z.ZodEnum<["starter", "growth", "professional", "enterprise"]>>;
    status: z.ZodOptional<z.ZodEnum<["active", "suspended", "cancelled"]>>;
}, "strip", z.ZodTypeAny, {
    status?: "active" | "suspended" | "cancelled" | undefined;
    name?: string | undefined;
    plan?: "starter" | "growth" | "professional" | "enterprise" | undefined;
}, {
    status?: "active" | "suspended" | "cancelled" | undefined;
    name?: string | undefined;
    plan?: "starter" | "growth" | "professional" | "enterprise" | undefined;
}>;
declare const organizationSettingsSchema: z.ZodObject<{
    aiTransparencyEnabled: z.ZodDefault<z.ZodBoolean>;
    proactiveBiasMonitoring: z.ZodDefault<z.ZodBoolean>;
    dataResidency: z.ZodDefault<z.ZodEnum<["us", "eu", "asia"]>>;
    llmCostLimit: z.ZodOptional<z.ZodNumber>;
    autoEscalationEnabled: z.ZodDefault<z.ZodBoolean>;
    escalationThreshold: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    aiTransparencyEnabled: boolean;
    proactiveBiasMonitoring: boolean;
    dataResidency: "us" | "eu" | "asia";
    autoEscalationEnabled: boolean;
    escalationThreshold: number;
    llmCostLimit?: number | undefined;
}, {
    aiTransparencyEnabled?: boolean | undefined;
    proactiveBiasMonitoring?: boolean | undefined;
    dataResidency?: "us" | "eu" | "asia" | undefined;
    llmCostLimit?: number | undefined;
    autoEscalationEnabled?: boolean | undefined;
    escalationThreshold?: number | undefined;
}>;
type Organization = z.infer<typeof organizationSchema>;
type CreateOrganizationInput = z.infer<typeof createOrganizationSchema>;
type UpdateOrganizationInput = z.infer<typeof updateOrganizationSchema>;
type OrganizationSettings = z.infer<typeof organizationSettingsSchema>;

/**
 * Conversation Management Schemas
 */
declare const messageSchema: z.ZodObject<{
    id: z.ZodString;
    content: z.ZodString;
    role: z.ZodEnum<["user", "assistant", "system"]>;
    agentType: z.ZodNullable<z.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>>;
    tokenCount: z.ZodNumber;
    cost: z.ZodNumber;
    sentiment: z.ZodNullable<z.ZodEnum<["positive", "neutral", "negative", "frustrated", "angry"]>>;
    intent: z.ZodNullable<z.ZodString>;
    metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
} & {
    createdAt: z.ZodDate;
    updatedAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    metadata: Record<string, unknown> | null;
    id: string;
    role: "user" | "assistant" | "system";
    createdAt: Date;
    updatedAt: Date;
    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | null;
    sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry" | null;
    content: string;
    tokenCount: number;
    cost: number;
    intent: string | null;
}, {
    metadata: Record<string, unknown> | null;
    id: string;
    role: "user" | "assistant" | "system";
    createdAt: Date;
    updatedAt: Date;
    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | null;
    sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry" | null;
    content: string;
    tokenCount: number;
    cost: number;
    intent: string | null;
}>;
declare const conversationSchema: z.ZodObject<{
    id: z.ZodString;
    customerId: z.ZodString;
    customerEmail: z.ZodNullable<z.ZodString>;
    customerName: z.ZodNullable<z.ZodString>;
    channel: z.ZodEnum<["web", "mobile", "email", "slack", "api"]>;
    status: z.ZodEnum<["active", "resolved", "escalated"]>;
    priority: z.ZodEnum<["low", "normal", "high", "urgent"]>;
    sentiment: z.ZodEnum<["positive", "neutral", "negative", "frustrated", "angry"]>;
    effortScore: z.ZodNullable<z.ZodNumber>;
    resolved: z.ZodBoolean;
    resolvedAt: z.ZodNullable<z.ZodDate>;
    firstResponseAt: z.ZodNullable<z.ZodDate>;
    contextSummary: z.ZodNullable<z.ZodString>;
    metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    organizationId: z.ZodString;
} & {
    createdAt: z.ZodDate;
    updatedAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    metadata: Record<string, unknown> | null;
    status: "active" | "resolved" | "escalated";
    id: string;
    organizationId: string;
    createdAt: Date;
    updatedAt: Date;
    customerId: string;
    customerEmail: string | null;
    customerName: string | null;
    channel: "email" | "web" | "mobile" | "slack" | "api";
    priority: "low" | "normal" | "high" | "urgent";
    resolved: boolean;
    sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
    effortScore: number | null;
    resolvedAt: Date | null;
    firstResponseAt: Date | null;
    contextSummary: string | null;
}, {
    metadata: Record<string, unknown> | null;
    status: "active" | "resolved" | "escalated";
    id: string;
    organizationId: string;
    createdAt: Date;
    updatedAt: Date;
    customerId: string;
    customerEmail: string | null;
    customerName: string | null;
    channel: "email" | "web" | "mobile" | "slack" | "api";
    priority: "low" | "normal" | "high" | "urgent";
    resolved: boolean;
    sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
    effortScore: number | null;
    resolvedAt: Date | null;
    firstResponseAt: Date | null;
    contextSummary: string | null;
}>;
declare const conversationWithMessagesSchema: z.ZodObject<{
    id: z.ZodString;
    customerId: z.ZodString;
    customerEmail: z.ZodNullable<z.ZodString>;
    customerName: z.ZodNullable<z.ZodString>;
    channel: z.ZodEnum<["web", "mobile", "email", "slack", "api"]>;
    status: z.ZodEnum<["active", "resolved", "escalated"]>;
    priority: z.ZodEnum<["low", "normal", "high", "urgent"]>;
    sentiment: z.ZodEnum<["positive", "neutral", "negative", "frustrated", "angry"]>;
    effortScore: z.ZodNullable<z.ZodNumber>;
    resolved: z.ZodBoolean;
    resolvedAt: z.ZodNullable<z.ZodDate>;
    firstResponseAt: z.ZodNullable<z.ZodDate>;
    contextSummary: z.ZodNullable<z.ZodString>;
    metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    organizationId: z.ZodString;
} & {
    createdAt: z.ZodDate;
    updatedAt: z.ZodDate;
} & {
    messages: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        content: z.ZodString;
        role: z.ZodEnum<["user", "assistant", "system"]>;
        agentType: z.ZodNullable<z.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>>;
        tokenCount: z.ZodNumber;
        cost: z.ZodNumber;
        sentiment: z.ZodNullable<z.ZodEnum<["positive", "neutral", "negative", "frustrated", "angry"]>>;
        intent: z.ZodNullable<z.ZodString>;
        metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    } & {
        createdAt: z.ZodDate;
        updatedAt: z.ZodDate;
    }, "strip", z.ZodTypeAny, {
        metadata: Record<string, unknown> | null;
        id: string;
        role: "user" | "assistant" | "system";
        createdAt: Date;
        updatedAt: Date;
        agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | null;
        sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry" | null;
        content: string;
        tokenCount: number;
        cost: number;
        intent: string | null;
    }, {
        metadata: Record<string, unknown> | null;
        id: string;
        role: "user" | "assistant" | "system";
        createdAt: Date;
        updatedAt: Date;
        agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | null;
        sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry" | null;
        content: string;
        tokenCount: number;
        cost: number;
        intent: string | null;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    metadata: Record<string, unknown> | null;
    status: "active" | "resolved" | "escalated";
    id: string;
    organizationId: string;
    createdAt: Date;
    updatedAt: Date;
    customerId: string;
    customerEmail: string | null;
    customerName: string | null;
    channel: "email" | "web" | "mobile" | "slack" | "api";
    priority: "low" | "normal" | "high" | "urgent";
    resolved: boolean;
    sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
    effortScore: number | null;
    resolvedAt: Date | null;
    firstResponseAt: Date | null;
    contextSummary: string | null;
    messages: {
        metadata: Record<string, unknown> | null;
        id: string;
        role: "user" | "assistant" | "system";
        createdAt: Date;
        updatedAt: Date;
        agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | null;
        sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry" | null;
        content: string;
        tokenCount: number;
        cost: number;
        intent: string | null;
    }[];
}, {
    metadata: Record<string, unknown> | null;
    status: "active" | "resolved" | "escalated";
    id: string;
    organizationId: string;
    createdAt: Date;
    updatedAt: Date;
    customerId: string;
    customerEmail: string | null;
    customerName: string | null;
    channel: "email" | "web" | "mobile" | "slack" | "api";
    priority: "low" | "normal" | "high" | "urgent";
    resolved: boolean;
    sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
    effortScore: number | null;
    resolvedAt: Date | null;
    firstResponseAt: Date | null;
    contextSummary: string | null;
    messages: {
        metadata: Record<string, unknown> | null;
        id: string;
        role: "user" | "assistant" | "system";
        createdAt: Date;
        updatedAt: Date;
        agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | null;
        sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry" | null;
        content: string;
        tokenCount: number;
        cost: number;
        intent: string | null;
    }[];
}>;
declare const createConversationSchema: z.ZodObject<{
    customerId: z.ZodString;
    customerEmail: z.ZodOptional<z.ZodString>;
    customerName: z.ZodOptional<z.ZodString>;
    channel: z.ZodDefault<z.ZodEnum<["web", "mobile", "email", "slack", "api"]>>;
    priority: z.ZodDefault<z.ZodEnum<["low", "normal", "high", "urgent"]>>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    customerId: string;
    channel: "email" | "web" | "mobile" | "slack" | "api";
    priority: "low" | "normal" | "high" | "urgent";
    metadata?: Record<string, unknown> | undefined;
    customerEmail?: string | undefined;
    customerName?: string | undefined;
}, {
    customerId: string;
    metadata?: Record<string, unknown> | undefined;
    customerEmail?: string | undefined;
    customerName?: string | undefined;
    channel?: "email" | "web" | "mobile" | "slack" | "api" | undefined;
    priority?: "low" | "normal" | "high" | "urgent" | undefined;
}>;
declare const sendMessageSchema: z.ZodObject<{
    content: z.ZodString;
    role: z.ZodDefault<z.ZodEnum<["user", "assistant"]>>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    role: "user" | "assistant";
    content: string;
    metadata?: Record<string, unknown> | undefined;
}, {
    content: string;
    metadata?: Record<string, unknown> | undefined;
    role?: "user" | "assistant" | undefined;
}>;
declare const updateConversationSchema: z.ZodObject<{
    status: z.ZodOptional<z.ZodEnum<["active", "resolved", "escalated"]>>;
    priority: z.ZodOptional<z.ZodEnum<["low", "normal", "high", "urgent"]>>;
    effortScore: z.ZodOptional<z.ZodNumber>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    metadata?: Record<string, unknown> | undefined;
    status?: "active" | "resolved" | "escalated" | undefined;
    priority?: "low" | "normal" | "high" | "urgent" | undefined;
    effortScore?: number | undefined;
}, {
    metadata?: Record<string, unknown> | undefined;
    status?: "active" | "resolved" | "escalated" | undefined;
    priority?: "low" | "normal" | "high" | "urgent" | undefined;
    effortScore?: number | undefined;
}>;
declare const conversationListResponseSchema: z.ZodObject<{
    conversations: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        customerId: z.ZodString;
        customerEmail: z.ZodNullable<z.ZodString>;
        customerName: z.ZodNullable<z.ZodString>;
        channel: z.ZodEnum<["web", "mobile", "email", "slack", "api"]>;
        status: z.ZodEnum<["active", "resolved", "escalated"]>;
        priority: z.ZodEnum<["low", "normal", "high", "urgent"]>;
        sentiment: z.ZodEnum<["positive", "neutral", "negative", "frustrated", "angry"]>;
        effortScore: z.ZodNullable<z.ZodNumber>;
        resolved: z.ZodBoolean;
        resolvedAt: z.ZodNullable<z.ZodDate>;
        firstResponseAt: z.ZodNullable<z.ZodDate>;
        contextSummary: z.ZodNullable<z.ZodString>;
        metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        organizationId: z.ZodString;
    } & {
        createdAt: z.ZodDate;
        updatedAt: z.ZodDate;
    }, "strip", z.ZodTypeAny, {
        metadata: Record<string, unknown> | null;
        status: "active" | "resolved" | "escalated";
        id: string;
        organizationId: string;
        createdAt: Date;
        updatedAt: Date;
        customerId: string;
        customerEmail: string | null;
        customerName: string | null;
        channel: "email" | "web" | "mobile" | "slack" | "api";
        priority: "low" | "normal" | "high" | "urgent";
        resolved: boolean;
        sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
        effortScore: number | null;
        resolvedAt: Date | null;
        firstResponseAt: Date | null;
        contextSummary: string | null;
    }, {
        metadata: Record<string, unknown> | null;
        status: "active" | "resolved" | "escalated";
        id: string;
        organizationId: string;
        createdAt: Date;
        updatedAt: Date;
        customerId: string;
        customerEmail: string | null;
        customerName: string | null;
        channel: "email" | "web" | "mobile" | "slack" | "api";
        priority: "low" | "normal" | "high" | "urgent";
        resolved: boolean;
        sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
        effortScore: number | null;
        resolvedAt: Date | null;
        firstResponseAt: Date | null;
        contextSummary: string | null;
    }>, "many">;
    pagination: z.ZodObject<{
        page: z.ZodNumber;
        limit: z.ZodNumber;
        total: z.ZodNumber;
        totalPages: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        page: number;
        limit: number;
        total: number;
        totalPages: number;
    }, {
        page: number;
        limit: number;
        total: number;
        totalPages: number;
    }>;
}, "strip", z.ZodTypeAny, {
    conversations: {
        metadata: Record<string, unknown> | null;
        status: "active" | "resolved" | "escalated";
        id: string;
        organizationId: string;
        createdAt: Date;
        updatedAt: Date;
        customerId: string;
        customerEmail: string | null;
        customerName: string | null;
        channel: "email" | "web" | "mobile" | "slack" | "api";
        priority: "low" | "normal" | "high" | "urgent";
        resolved: boolean;
        sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
        effortScore: number | null;
        resolvedAt: Date | null;
        firstResponseAt: Date | null;
        contextSummary: string | null;
    }[];
    pagination: {
        page: number;
        limit: number;
        total: number;
        totalPages: number;
    };
}, {
    conversations: {
        metadata: Record<string, unknown> | null;
        status: "active" | "resolved" | "escalated";
        id: string;
        organizationId: string;
        createdAt: Date;
        updatedAt: Date;
        customerId: string;
        customerEmail: string | null;
        customerName: string | null;
        channel: "email" | "web" | "mobile" | "slack" | "api";
        priority: "low" | "normal" | "high" | "urgent";
        resolved: boolean;
        sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
        effortScore: number | null;
        resolvedAt: Date | null;
        firstResponseAt: Date | null;
        contextSummary: string | null;
    }[];
    pagination: {
        page: number;
        limit: number;
        total: number;
        totalPages: number;
    };
}>;
declare const conversationFiltersSchema: z.ZodObject<{
    status: z.ZodOptional<z.ZodEnum<["active", "resolved", "escalated"]>>;
    priority: z.ZodOptional<z.ZodEnum<["low", "normal", "high", "urgent"]>>;
    channel: z.ZodOptional<z.ZodEnum<["web", "mobile", "email", "slack", "api"]>>;
    customerId: z.ZodOptional<z.ZodString>;
    fromDate: z.ZodOptional<z.ZodDate>;
    toDate: z.ZodOptional<z.ZodDate>;
}, "strip", z.ZodTypeAny, {
    status?: "active" | "resolved" | "escalated" | undefined;
    customerId?: string | undefined;
    channel?: "email" | "web" | "mobile" | "slack" | "api" | undefined;
    priority?: "low" | "normal" | "high" | "urgent" | undefined;
    fromDate?: Date | undefined;
    toDate?: Date | undefined;
}, {
    status?: "active" | "resolved" | "escalated" | undefined;
    customerId?: string | undefined;
    channel?: "email" | "web" | "mobile" | "slack" | "api" | undefined;
    priority?: "low" | "normal" | "high" | "urgent" | undefined;
    fromDate?: Date | undefined;
    toDate?: Date | undefined;
}>;
type Message = z.infer<typeof messageSchema>;
type Conversation = z.infer<typeof conversationSchema>;
type ConversationWithMessages = z.infer<typeof conversationWithMessagesSchema>;
type CreateConversationInput = z.infer<typeof createConversationSchema>;
type SendMessageInput = z.infer<typeof sendMessageSchema>;
type UpdateConversationInput = z.infer<typeof updateConversationSchema>;
type ConversationListResponse = z.infer<typeof conversationListResponseSchema>;
type ConversationFilters = z.infer<typeof conversationFiltersSchema>;

/**
 * Agent System Schemas
 */
declare const agentTypeEnum: z.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>;
declare const agentActionSchema: z.ZodObject<{
    id: z.ZodString;
    agentType: z.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>;
    action: z.ZodString;
    status: z.ZodEnum<["pending", "in_progress", "completed", "failed"]>;
    input: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    output: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    toolName: z.ZodNullable<z.ZodString>;
    toolParams: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    toolResult: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    reasoning: z.ZodNullable<z.ZodString>;
    tokenCount: z.ZodNumber;
    cost: z.ZodNumber;
    duration: z.ZodNullable<z.ZodNumber>;
    error: z.ZodNullable<z.ZodString>;
    conversationId: z.ZodString;
    completedAt: z.ZodNullable<z.ZodDate>;
} & {
    createdAt: z.ZodDate;
    updatedAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    status: "pending" | "in_progress" | "completed" | "failed";
    id: string;
    createdAt: Date;
    updatedAt: Date;
    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
    error: string | null;
    tokenCount: number;
    cost: number;
    conversationId: string;
    action: string;
    input: Record<string, unknown> | null;
    output: Record<string, unknown> | null;
    toolName: string | null;
    toolParams: Record<string, unknown> | null;
    toolResult: Record<string, unknown> | null;
    reasoning: string | null;
    duration: number | null;
    completedAt: Date | null;
}, {
    status: "pending" | "in_progress" | "completed" | "failed";
    id: string;
    createdAt: Date;
    updatedAt: Date;
    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
    error: string | null;
    tokenCount: number;
    cost: number;
    conversationId: string;
    action: string;
    input: Record<string, unknown> | null;
    output: Record<string, unknown> | null;
    toolName: string | null;
    toolParams: Record<string, unknown> | null;
    toolResult: Record<string, unknown> | null;
    reasoning: string | null;
    duration: number | null;
    completedAt: Date | null;
}>;
declare const agentStatusSchema: z.ZodObject<{
    agentType: z.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>;
    status: z.ZodEnum<["active", "idle", "error"]>;
    currentLoad: z.ZodNumber;
    actionsPerHour: z.ZodNumber;
    averageResponseTime: z.ZodNumber;
    errorRate: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    status: "error" | "active" | "idle";
    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
    currentLoad: number;
    actionsPerHour: number;
    averageResponseTime: number;
    errorRate: number;
}, {
    status: "error" | "active" | "idle";
    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
    currentLoad: number;
    actionsPerHour: number;
    averageResponseTime: number;
    errorRate: number;
}>;
declare const agentConfigSchema: z.ZodObject<{
    agentType: z.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>;
    enabled: z.ZodBoolean;
    maxConcurrent: z.ZodDefault<z.ZodNumber>;
    timeout: z.ZodDefault<z.ZodNumber>;
    retryAttempts: z.ZodDefault<z.ZodNumber>;
    llmModel: z.ZodDefault<z.ZodString>;
    temperature: z.ZodDefault<z.ZodNumber>;
    systemPrompt: z.ZodOptional<z.ZodString>;
    tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
    enabled: boolean;
    maxConcurrent: number;
    timeout: number;
    retryAttempts: number;
    llmModel: string;
    temperature: number;
    tools?: string[] | undefined;
    systemPrompt?: string | undefined;
}, {
    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
    enabled: boolean;
    tools?: string[] | undefined;
    maxConcurrent?: number | undefined;
    timeout?: number | undefined;
    retryAttempts?: number | undefined;
    llmModel?: string | undefined;
    temperature?: number | undefined;
    systemPrompt?: string | undefined;
}>;
declare const agentMetricsSchema: z.ZodObject<{
    agentType: z.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>;
    totalActions: z.ZodNumber;
    successfulActions: z.ZodNumber;
    failedActions: z.ZodNumber;
    averageDuration: z.ZodNumber;
    totalCost: z.ZodNumber;
    totalTokens: z.ZodNumber;
    period: z.ZodObject<{
        from: z.ZodDate;
        to: z.ZodDate;
    }, "strip", z.ZodTypeAny, {
        from: Date;
        to: Date;
    }, {
        from: Date;
        to: Date;
    }>;
}, "strip", z.ZodTypeAny, {
    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
    totalActions: number;
    successfulActions: number;
    failedActions: number;
    averageDuration: number;
    totalCost: number;
    totalTokens: number;
    period: {
        from: Date;
        to: Date;
    };
}, {
    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
    totalActions: number;
    successfulActions: number;
    failedActions: number;
    averageDuration: number;
    totalCost: number;
    totalTokens: number;
    period: {
        from: Date;
        to: Date;
    };
}>;
declare const agenticSystemStatusSchema: z.ZodObject<{
    orchestratorLoad: z.ZodNumber;
    resolverActionsPerHour: z.ZodNumber;
    agents: z.ZodArray<z.ZodObject<{
        type: z.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>;
        status: z.ZodEnum<["active", "idle"]>;
    }, "strip", z.ZodTypeAny, {
        type: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
        status: "active" | "idle";
    }, {
        type: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
        status: "active" | "idle";
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    orchestratorLoad: number;
    resolverActionsPerHour: number;
    agents: {
        type: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
        status: "active" | "idle";
    }[];
}, {
    orchestratorLoad: number;
    resolverActionsPerHour: number;
    agents: {
        type: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
        status: "active" | "idle";
    }[];
}>;
type AgentType = z.infer<typeof agentTypeEnum>;
type AgentAction = z.infer<typeof agentActionSchema>;
type AgentStatus = z.infer<typeof agentStatusSchema>;
type AgentConfig = z.infer<typeof agentConfigSchema>;
type AgentMetrics = z.infer<typeof agentMetricsSchema>;
type AgenticSystemStatus = z.infer<typeof agenticSystemStatusSchema>;

/**
 * Escalation System Schemas
 */
declare const escalationSchema: z.ZodObject<{
    id: z.ZodString;
    reason: z.ZodString;
    priority: z.ZodEnum<["low", "normal", "high", "urgent"]>;
    status: z.ZodEnum<["new", "assigned", "in_progress", "resolved"]>;
    aiSummary: z.ZodString;
    customerContext: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    assignedAt: z.ZodNullable<z.ZodDate>;
    resolvedAt: z.ZodNullable<z.ZodDate>;
    resolution: z.ZodNullable<z.ZodString>;
    conversationId: z.ZodString;
    organizationId: z.ZodString;
    assignedToId: z.ZodNullable<z.ZodString>;
    assignedTo: z.ZodNullable<z.ZodObject<{
        id: z.ZodString;
        name: z.ZodString;
        email: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        email: string;
        id: string;
        name: string;
    }, {
        email: string;
        id: string;
        name: string;
    }>>;
} & {
    createdAt: z.ZodDate;
    updatedAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    status: "resolved" | "in_progress" | "new" | "assigned";
    id: string;
    organizationId: string;
    createdAt: Date;
    updatedAt: Date;
    priority: "low" | "normal" | "high" | "urgent";
    resolvedAt: Date | null;
    conversationId: string;
    reason: string;
    aiSummary: string;
    customerContext: Record<string, unknown> | null;
    assignedAt: Date | null;
    resolution: string | null;
    assignedToId: string | null;
    assignedTo: {
        email: string;
        id: string;
        name: string;
    } | null;
}, {
    status: "resolved" | "in_progress" | "new" | "assigned";
    id: string;
    organizationId: string;
    createdAt: Date;
    updatedAt: Date;
    priority: "low" | "normal" | "high" | "urgent";
    resolvedAt: Date | null;
    conversationId: string;
    reason: string;
    aiSummary: string;
    customerContext: Record<string, unknown> | null;
    assignedAt: Date | null;
    resolution: string | null;
    assignedToId: string | null;
    assignedTo: {
        email: string;
        id: string;
        name: string;
    } | null;
}>;
declare const createEscalationSchema: z.ZodObject<{
    conversationId: z.ZodString;
    reason: z.ZodString;
    priority: z.ZodDefault<z.ZodEnum<["low", "normal", "high", "urgent"]>>;
    aiSummary: z.ZodString;
    customerContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    priority: "low" | "normal" | "high" | "urgent";
    conversationId: string;
    reason: string;
    aiSummary: string;
    customerContext?: Record<string, unknown> | undefined;
}, {
    conversationId: string;
    reason: string;
    aiSummary: string;
    priority?: "low" | "normal" | "high" | "urgent" | undefined;
    customerContext?: Record<string, unknown> | undefined;
}>;
declare const updateEscalationSchema: z.ZodObject<{
    status: z.ZodOptional<z.ZodEnum<["new", "assigned", "in_progress", "resolved"]>>;
    priority: z.ZodOptional<z.ZodEnum<["low", "normal", "high", "urgent"]>>;
    assignedToId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    resolution: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    status?: "resolved" | "in_progress" | "new" | "assigned" | undefined;
    priority?: "low" | "normal" | "high" | "urgent" | undefined;
    resolution?: string | undefined;
    assignedToId?: string | null | undefined;
}, {
    status?: "resolved" | "in_progress" | "new" | "assigned" | undefined;
    priority?: "low" | "normal" | "high" | "urgent" | undefined;
    resolution?: string | undefined;
    assignedToId?: string | null | undefined;
}>;
declare const escalationListResponseSchema: z.ZodObject<{
    escalations: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        reason: z.ZodString;
        priority: z.ZodEnum<["low", "normal", "high", "urgent"]>;
        status: z.ZodEnum<["new", "assigned", "in_progress", "resolved"]>;
        aiSummary: z.ZodString;
        customerContext: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        assignedAt: z.ZodNullable<z.ZodDate>;
        resolvedAt: z.ZodNullable<z.ZodDate>;
        resolution: z.ZodNullable<z.ZodString>;
        conversationId: z.ZodString;
        organizationId: z.ZodString;
        assignedToId: z.ZodNullable<z.ZodString>;
        assignedTo: z.ZodNullable<z.ZodObject<{
            id: z.ZodString;
            name: z.ZodString;
            email: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            email: string;
            id: string;
            name: string;
        }, {
            email: string;
            id: string;
            name: string;
        }>>;
    } & {
        createdAt: z.ZodDate;
        updatedAt: z.ZodDate;
    }, "strip", z.ZodTypeAny, {
        status: "resolved" | "in_progress" | "new" | "assigned";
        id: string;
        organizationId: string;
        createdAt: Date;
        updatedAt: Date;
        priority: "low" | "normal" | "high" | "urgent";
        resolvedAt: Date | null;
        conversationId: string;
        reason: string;
        aiSummary: string;
        customerContext: Record<string, unknown> | null;
        assignedAt: Date | null;
        resolution: string | null;
        assignedToId: string | null;
        assignedTo: {
            email: string;
            id: string;
            name: string;
        } | null;
    }, {
        status: "resolved" | "in_progress" | "new" | "assigned";
        id: string;
        organizationId: string;
        createdAt: Date;
        updatedAt: Date;
        priority: "low" | "normal" | "high" | "urgent";
        resolvedAt: Date | null;
        conversationId: string;
        reason: string;
        aiSummary: string;
        customerContext: Record<string, unknown> | null;
        assignedAt: Date | null;
        resolution: string | null;
        assignedToId: string | null;
        assignedTo: {
            email: string;
            id: string;
            name: string;
        } | null;
    }>, "many">;
    pagination: z.ZodObject<{
        page: z.ZodNumber;
        limit: z.ZodNumber;
        total: z.ZodNumber;
        totalPages: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        page: number;
        limit: number;
        total: number;
        totalPages: number;
    }, {
        page: number;
        limit: number;
        total: number;
        totalPages: number;
    }>;
}, "strip", z.ZodTypeAny, {
    pagination: {
        page: number;
        limit: number;
        total: number;
        totalPages: number;
    };
    escalations: {
        status: "resolved" | "in_progress" | "new" | "assigned";
        id: string;
        organizationId: string;
        createdAt: Date;
        updatedAt: Date;
        priority: "low" | "normal" | "high" | "urgent";
        resolvedAt: Date | null;
        conversationId: string;
        reason: string;
        aiSummary: string;
        customerContext: Record<string, unknown> | null;
        assignedAt: Date | null;
        resolution: string | null;
        assignedToId: string | null;
        assignedTo: {
            email: string;
            id: string;
            name: string;
        } | null;
    }[];
}, {
    pagination: {
        page: number;
        limit: number;
        total: number;
        totalPages: number;
    };
    escalations: {
        status: "resolved" | "in_progress" | "new" | "assigned";
        id: string;
        organizationId: string;
        createdAt: Date;
        updatedAt: Date;
        priority: "low" | "normal" | "high" | "urgent";
        resolvedAt: Date | null;
        conversationId: string;
        reason: string;
        aiSummary: string;
        customerContext: Record<string, unknown> | null;
        assignedAt: Date | null;
        resolution: string | null;
        assignedToId: string | null;
        assignedTo: {
            email: string;
            id: string;
            name: string;
        } | null;
    }[];
}>;
declare const escalationFiltersSchema: z.ZodObject<{
    status: z.ZodOptional<z.ZodEnum<["new", "assigned", "in_progress", "resolved"]>>;
    priority: z.ZodOptional<z.ZodEnum<["low", "normal", "high", "urgent"]>>;
    assignedToId: z.ZodOptional<z.ZodString>;
    fromDate: z.ZodOptional<z.ZodDate>;
    toDate: z.ZodOptional<z.ZodDate>;
}, "strip", z.ZodTypeAny, {
    status?: "resolved" | "in_progress" | "new" | "assigned" | undefined;
    priority?: "low" | "normal" | "high" | "urgent" | undefined;
    fromDate?: Date | undefined;
    toDate?: Date | undefined;
    assignedToId?: string | undefined;
}, {
    status?: "resolved" | "in_progress" | "new" | "assigned" | undefined;
    priority?: "low" | "normal" | "high" | "urgent" | undefined;
    fromDate?: Date | undefined;
    toDate?: Date | undefined;
    assignedToId?: string | undefined;
}>;
declare const assignEscalationSchema: z.ZodObject<{
    userId: z.ZodString;
}, "strip", z.ZodTypeAny, {
    userId: string;
}, {
    userId: string;
}>;
type Escalation = z.infer<typeof escalationSchema>;
type CreateEscalationInput = z.infer<typeof createEscalationSchema>;
type UpdateEscalationInput = z.infer<typeof updateEscalationSchema>;
type EscalationListResponse = z.infer<typeof escalationListResponseSchema>;
type EscalationFilters = z.infer<typeof escalationFiltersSchema>;
type AssignEscalationInput = z.infer<typeof assignEscalationSchema>;

/**
 * Analytics & Metrics Schemas
 */
declare const dashboardMetricsSchema: z.ZodObject<{
    firstContactResolution: z.ZodObject<{
        value: z.ZodNumber;
        change: z.ZodNumber;
        changeType: z.ZodEnum<["increase", "decrease"]>;
    }, "strip", z.ZodTypeAny, {
        value: number;
        change: number;
        changeType: "increase" | "decrease";
    }, {
        value: number;
        change: number;
        changeType: "increase" | "decrease";
    }>;
    customerEffortScore: z.ZodObject<{
        value: z.ZodNumber;
        change: z.ZodNumber;
        changeType: z.ZodEnum<["increase", "decrease"]>;
    }, "strip", z.ZodTypeAny, {
        value: number;
        change: number;
        changeType: "increase" | "decrease";
    }, {
        value: number;
        change: number;
        changeType: "increase" | "decrease";
    }>;
    emotionalValueIndex: z.ZodObject<{
        value: z.ZodNumber;
        change: z.ZodNumber;
        changeType: z.ZodEnum<["increase", "decrease"]>;
    }, "strip", z.ZodTypeAny, {
        value: number;
        change: number;
        changeType: "increase" | "decrease";
    }, {
        value: number;
        change: number;
        changeType: "increase" | "decrease";
    }>;
    supportROI: z.ZodObject<{
        value: z.ZodNumber;
        retainedRevenue: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        value: number;
        retainedRevenue: number;
    }, {
        value: number;
        retainedRevenue: number;
    }>;
}, "strip", z.ZodTypeAny, {
    firstContactResolution: {
        value: number;
        change: number;
        changeType: "increase" | "decrease";
    };
    customerEffortScore: {
        value: number;
        change: number;
        changeType: "increase" | "decrease";
    };
    emotionalValueIndex: {
        value: number;
        change: number;
        changeType: "increase" | "decrease";
    };
    supportROI: {
        value: number;
        retainedRevenue: number;
    };
}, {
    firstContactResolution: {
        value: number;
        change: number;
        changeType: "increase" | "decrease";
    };
    customerEffortScore: {
        value: number;
        change: number;
        changeType: "increase" | "decrease";
    };
    emotionalValueIndex: {
        value: number;
        change: number;
        changeType: "increase" | "decrease";
    };
    supportROI: {
        value: number;
        retainedRevenue: number;
    };
}>;
declare const sentimentOverTimeSchema: z.ZodObject<{
    dataPoints: z.ZodArray<z.ZodObject<{
        date: z.ZodDate;
        evi: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        date: Date;
        evi: number;
    }, {
        date: Date;
        evi: number;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    dataPoints: {
        date: Date;
        evi: number;
    }[];
}, {
    dataPoints: {
        date: Date;
        evi: number;
    }[];
}>;
declare const frustrationDriverSchema: z.ZodObject<{
    topic: z.ZodString;
    mentions: z.ZodNumber;
    percentage: z.ZodNumber;
    severity: z.ZodEnum<["low", "medium", "high"]>;
}, "strip", z.ZodTypeAny, {
    topic: string;
    mentions: number;
    percentage: number;
    severity: "low" | "high" | "medium";
}, {
    topic: string;
    mentions: number;
    percentage: number;
    severity: "low" | "high" | "medium";
}>;
declare const frustrationDriversSchema: z.ZodObject<{
    drivers: z.ZodArray<z.ZodObject<{
        topic: z.ZodString;
        mentions: z.ZodNumber;
        percentage: z.ZodNumber;
        severity: z.ZodEnum<["low", "medium", "high"]>;
    }, "strip", z.ZodTypeAny, {
        topic: string;
        mentions: number;
        percentage: number;
        severity: "low" | "high" | "medium";
    }, {
        topic: string;
        mentions: number;
        percentage: number;
        severity: "low" | "high" | "medium";
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    drivers: {
        topic: string;
        mentions: number;
        percentage: number;
        severity: "low" | "high" | "medium";
    }[];
}, {
    drivers: {
        topic: string;
        mentions: number;
        percentage: number;
        severity: "low" | "high" | "medium";
    }[];
}>;
declare const emergingIssueSchema: z.ZodObject<{
    topic: z.ZodString;
    mentions: z.ZodNumber;
    growthRate: z.ZodNumber;
}, "strip", z.ZodTypeAny, {
    topic: string;
    mentions: number;
    growthRate: number;
}, {
    topic: string;
    mentions: number;
    growthRate: number;
}>;
declare const emergingIssuesSchema: z.ZodObject<{
    issues: z.ZodArray<z.ZodObject<{
        topic: z.ZodString;
        mentions: z.ZodNumber;
        growthRate: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        topic: string;
        mentions: number;
        growthRate: number;
    }, {
        topic: string;
        mentions: number;
        growthRate: number;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    issues: {
        topic: string;
        mentions: number;
        growthRate: number;
    }[];
}, {
    issues: {
        topic: string;
        mentions: number;
        growthRate: number;
    }[];
}>;
declare const conversationMetricsSchema: z.ZodObject<{
    id: z.ZodString;
    conversationId: z.ZodString;
    firstContactResolution: z.ZodBoolean;
    effortScore: z.ZodNullable<z.ZodNumber>;
    emotionalValueIndex: z.ZodNullable<z.ZodNumber>;
    totalMessages: z.ZodNumber;
    totalTokens: z.ZodNumber;
    totalCost: z.ZodNumber;
    agentsInvolved: z.ZodArray<z.ZodString, "many">;
    toolsUsed: z.ZodArray<z.ZodString, "many">;
    durationSeconds: z.ZodNullable<z.ZodNumber>;
    resolutionTimeSeconds: z.ZodNullable<z.ZodNumber>;
    calculatedAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    id: string;
    effortScore: number | null;
    totalCost: number;
    totalTokens: number;
    conversationId: string;
    firstContactResolution: boolean;
    emotionalValueIndex: number | null;
    totalMessages: number;
    agentsInvolved: string[];
    toolsUsed: string[];
    durationSeconds: number | null;
    resolutionTimeSeconds: number | null;
    calculatedAt: Date;
}, {
    id: string;
    effortScore: number | null;
    totalCost: number;
    totalTokens: number;
    conversationId: string;
    firstContactResolution: boolean;
    emotionalValueIndex: number | null;
    totalMessages: number;
    agentsInvolved: string[];
    toolsUsed: string[];
    durationSeconds: number | null;
    resolutionTimeSeconds: number | null;
    calculatedAt: Date;
}>;
declare const finOpsMetricsSchema: z.ZodObject<{
    totalSpend: z.ZodObject<{
        value: z.ZodNumber;
        period: z.ZodString;
        change: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        value: number;
        period: string;
        change: number;
    }, {
        value: number;
        period: string;
        change: number;
    }>;
    resolvedConversations: z.ZodObject<{
        value: z.ZodNumber;
        change: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        value: number;
        change: number;
    }, {
        value: number;
        change: number;
    }>;
    avgCostPerResolution: z.ZodObject<{
        value: z.ZodNumber;
        change: z.ZodNumber;
        changeType: z.ZodEnum<["increase", "decrease"]>;
    }, "strip", z.ZodTypeAny, {
        value: number;
        change: number;
        changeType: "increase" | "decrease";
    }, {
        value: number;
        change: number;
        changeType: "increase" | "decrease";
    }>;
    dataEgressFees: z.ZodObject<{
        value: z.ZodNumber;
        poweredBy: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        value: number;
        poweredBy: string;
    }, {
        value: number;
        poweredBy: string;
    }>;
    spendOverTime: z.ZodArray<z.ZodObject<{
        date: z.ZodDate;
        spend: z.ZodNumber;
        limit: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        date: Date;
        limit: number;
        spend: number;
    }, {
        date: Date;
        limit: number;
        spend: number;
    }>, "many">;
    usageBreakdown: z.ZodArray<z.ZodObject<{
        conversationId: z.ZodString;
        date: z.ZodDate;
        agentsInvolved: z.ZodArray<z.ZodString, "many">;
        tokens: z.ZodNumber;
        totalCost: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        date: Date;
        totalCost: number;
        conversationId: string;
        agentsInvolved: string[];
        tokens: number;
    }, {
        date: Date;
        totalCost: number;
        conversationId: string;
        agentsInvolved: string[];
        tokens: number;
    }>, "many">;
}, "strip", z.ZodTypeAny, {
    totalSpend: {
        value: number;
        period: string;
        change: number;
    };
    resolvedConversations: {
        value: number;
        change: number;
    };
    avgCostPerResolution: {
        value: number;
        change: number;
        changeType: "increase" | "decrease";
    };
    dataEgressFees: {
        value: number;
        poweredBy: string;
    };
    spendOverTime: {
        date: Date;
        limit: number;
        spend: number;
    }[];
    usageBreakdown: {
        date: Date;
        totalCost: number;
        conversationId: string;
        agentsInvolved: string[];
        tokens: number;
    }[];
}, {
    totalSpend: {
        value: number;
        period: string;
        change: number;
    };
    resolvedConversations: {
        value: number;
        change: number;
    };
    avgCostPerResolution: {
        value: number;
        change: number;
        changeType: "increase" | "decrease";
    };
    dataEgressFees: {
        value: number;
        poweredBy: string;
    };
    spendOverTime: {
        date: Date;
        limit: number;
        spend: number;
    }[];
    usageBreakdown: {
        date: Date;
        totalCost: number;
        conversationId: string;
        agentsInvolved: string[];
        tokens: number;
    }[];
}>;
declare const analyticsQuerySchema: z.ZodObject<{
    from: z.ZodDate;
    to: z.ZodDate;
    granularity: z.ZodDefault<z.ZodEnum<["hour", "day", "week", "month"]>>;
}, "strip", z.ZodTypeAny, {
    from: Date;
    to: Date;
    granularity: "hour" | "day" | "week" | "month";
}, {
    from: Date;
    to: Date;
    granularity?: "hour" | "day" | "week" | "month" | undefined;
}>;
type DashboardMetrics = z.infer<typeof dashboardMetricsSchema>;
type SentimentOverTime = z.infer<typeof sentimentOverTimeSchema>;
type FrustrationDriver = z.infer<typeof frustrationDriverSchema>;
type FrustrationDrivers = z.infer<typeof frustrationDriversSchema>;
type EmergingIssue = z.infer<typeof emergingIssueSchema>;
type EmergingIssues = z.infer<typeof emergingIssuesSchema>;
type ConversationMetrics = z.infer<typeof conversationMetricsSchema>;
type FinOpsMetrics = z.infer<typeof finOpsMetricsSchema>;
type AnalyticsQuery = z.infer<typeof analyticsQuerySchema>;

/**
 * Audit Trail & Governance Schemas
 */
declare const auditLogSchema: z.ZodObject<{
    id: z.ZodString;
    action: z.ZodString;
    actorType: z.ZodEnum<["user", "agent", "system"]>;
    actorId: z.ZodNullable<z.ZodString>;
    targetType: z.ZodNullable<z.ZodString>;
    targetId: z.ZodNullable<z.ZodString>;
    details: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    decision: z.ZodNullable<z.ZodString>;
    reasoning: z.ZodNullable<z.ZodString>;
    rbacCheck: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    ipAddress: z.ZodNullable<z.ZodString>;
    userAgent: z.ZodNullable<z.ZodString>;
    timestamp: z.ZodDate;
    organizationId: z.ZodString;
    userId: z.ZodNullable<z.ZodString>;
    agentActionId: z.ZodNullable<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    id: string;
    organizationId: string;
    details: Record<string, unknown>;
    userId: string | null;
    action: string;
    reasoning: string | null;
    actorType: "user" | "agent" | "system";
    actorId: string | null;
    targetType: string | null;
    targetId: string | null;
    decision: string | null;
    rbacCheck: Record<string, unknown> | null;
    ipAddress: string | null;
    userAgent: string | null;
    timestamp: Date;
    agentActionId: string | null;
}, {
    id: string;
    organizationId: string;
    details: Record<string, unknown>;
    userId: string | null;
    action: string;
    reasoning: string | null;
    actorType: "user" | "agent" | "system";
    actorId: string | null;
    targetType: string | null;
    targetId: string | null;
    decision: string | null;
    rbacCheck: Record<string, unknown> | null;
    ipAddress: string | null;
    userAgent: string | null;
    timestamp: Date;
    agentActionId: string | null;
}>;
declare const auditLogFiltersSchema: z.ZodObject<{
    action: z.ZodOptional<z.ZodString>;
    actorType: z.ZodOptional<z.ZodEnum<["user", "agent", "system"]>>;
    actorId: z.ZodOptional<z.ZodString>;
    targetType: z.ZodOptional<z.ZodString>;
    targetId: z.ZodOptional<z.ZodString>;
    fromDate: z.ZodOptional<z.ZodDate>;
    toDate: z.ZodOptional<z.ZodDate>;
}, "strip", z.ZodTypeAny, {
    fromDate?: Date | undefined;
    toDate?: Date | undefined;
    action?: string | undefined;
    actorType?: "user" | "agent" | "system" | undefined;
    actorId?: string | undefined;
    targetType?: string | undefined;
    targetId?: string | undefined;
}, {
    fromDate?: Date | undefined;
    toDate?: Date | undefined;
    action?: string | undefined;
    actorType?: "user" | "agent" | "system" | undefined;
    actorId?: string | undefined;
    targetType?: string | undefined;
    targetId?: string | undefined;
}>;
declare const auditLogListResponseSchema: z.ZodObject<{
    logs: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        action: z.ZodString;
        actorType: z.ZodEnum<["user", "agent", "system"]>;
        actorId: z.ZodNullable<z.ZodString>;
        targetType: z.ZodNullable<z.ZodString>;
        targetId: z.ZodNullable<z.ZodString>;
        details: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        decision: z.ZodNullable<z.ZodString>;
        reasoning: z.ZodNullable<z.ZodString>;
        rbacCheck: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        ipAddress: z.ZodNullable<z.ZodString>;
        userAgent: z.ZodNullable<z.ZodString>;
        timestamp: z.ZodDate;
        organizationId: z.ZodString;
        userId: z.ZodNullable<z.ZodString>;
        agentActionId: z.ZodNullable<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        id: string;
        organizationId: string;
        details: Record<string, unknown>;
        userId: string | null;
        action: string;
        reasoning: string | null;
        actorType: "user" | "agent" | "system";
        actorId: string | null;
        targetType: string | null;
        targetId: string | null;
        decision: string | null;
        rbacCheck: Record<string, unknown> | null;
        ipAddress: string | null;
        userAgent: string | null;
        timestamp: Date;
        agentActionId: string | null;
    }, {
        id: string;
        organizationId: string;
        details: Record<string, unknown>;
        userId: string | null;
        action: string;
        reasoning: string | null;
        actorType: "user" | "agent" | "system";
        actorId: string | null;
        targetType: string | null;
        targetId: string | null;
        decision: string | null;
        rbacCheck: Record<string, unknown> | null;
        ipAddress: string | null;
        userAgent: string | null;
        timestamp: Date;
        agentActionId: string | null;
    }>, "many">;
    pagination: z.ZodObject<{
        page: z.ZodNumber;
        limit: z.ZodNumber;
        total: z.ZodNumber;
        totalPages: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        page: number;
        limit: number;
        total: number;
        totalPages: number;
    }, {
        page: number;
        limit: number;
        total: number;
        totalPages: number;
    }>;
}, "strip", z.ZodTypeAny, {
    pagination: {
        page: number;
        limit: number;
        total: number;
        totalPages: number;
    };
    logs: {
        id: string;
        organizationId: string;
        details: Record<string, unknown>;
        userId: string | null;
        action: string;
        reasoning: string | null;
        actorType: "user" | "agent" | "system";
        actorId: string | null;
        targetType: string | null;
        targetId: string | null;
        decision: string | null;
        rbacCheck: Record<string, unknown> | null;
        ipAddress: string | null;
        userAgent: string | null;
        timestamp: Date;
        agentActionId: string | null;
    }[];
}, {
    pagination: {
        page: number;
        limit: number;
        total: number;
        totalPages: number;
    };
    logs: {
        id: string;
        organizationId: string;
        details: Record<string, unknown>;
        userId: string | null;
        action: string;
        reasoning: string | null;
        actorType: "user" | "agent" | "system";
        actorId: string | null;
        targetType: string | null;
        targetId: string | null;
        decision: string | null;
        rbacCheck: Record<string, unknown> | null;
        ipAddress: string | null;
        userAgent: string | null;
        timestamp: Date;
        agentActionId: string | null;
    }[];
}>;
declare const rbacPermissionSchema: z.ZodObject<{
    resource: z.ZodString;
    action: z.ZodString;
    allowed: z.ZodBoolean;
    reason: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    action: string;
    resource: string;
    allowed: boolean;
    reason?: string | undefined;
}, {
    action: string;
    resource: string;
    allowed: boolean;
    reason?: string | undefined;
}>;
declare const exportAuditLogSchema: z.ZodObject<{
    format: z.ZodEnum<["json", "csv"]>;
    filters: z.ZodOptional<z.ZodObject<{
        action: z.ZodOptional<z.ZodString>;
        actorType: z.ZodOptional<z.ZodEnum<["user", "agent", "system"]>>;
        actorId: z.ZodOptional<z.ZodString>;
        targetType: z.ZodOptional<z.ZodString>;
        targetId: z.ZodOptional<z.ZodString>;
        fromDate: z.ZodOptional<z.ZodDate>;
        toDate: z.ZodOptional<z.ZodDate>;
    }, "strip", z.ZodTypeAny, {
        fromDate?: Date | undefined;
        toDate?: Date | undefined;
        action?: string | undefined;
        actorType?: "user" | "agent" | "system" | undefined;
        actorId?: string | undefined;
        targetType?: string | undefined;
        targetId?: string | undefined;
    }, {
        fromDate?: Date | undefined;
        toDate?: Date | undefined;
        action?: string | undefined;
        actorType?: "user" | "agent" | "system" | undefined;
        actorId?: string | undefined;
        targetType?: string | undefined;
        targetId?: string | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    format: "json" | "csv";
    filters?: {
        fromDate?: Date | undefined;
        toDate?: Date | undefined;
        action?: string | undefined;
        actorType?: "user" | "agent" | "system" | undefined;
        actorId?: string | undefined;
        targetType?: string | undefined;
        targetId?: string | undefined;
    } | undefined;
}, {
    format: "json" | "csv";
    filters?: {
        fromDate?: Date | undefined;
        toDate?: Date | undefined;
        action?: string | undefined;
        actorType?: "user" | "agent" | "system" | undefined;
        actorId?: string | undefined;
        targetType?: string | undefined;
        targetId?: string | undefined;
    } | undefined;
}>;
type AuditLog = z.infer<typeof auditLogSchema>;
type AuditLogFilters = z.infer<typeof auditLogFiltersSchema>;
type AuditLogListResponse = z.infer<typeof auditLogListResponseSchema>;
type RBACPermission = z.infer<typeof rbacPermissionSchema>;
type ExportAuditLogInput = z.infer<typeof exportAuditLogSchema>;

/**
 * Integrations & Webhooks Schemas
 */
declare const integrationTypeEnum: z.ZodEnum<["salesforce", "slack", "zendesk"]>;
declare const integrationSchema: z.ZodObject<{
    id: z.ZodString;
    type: z.ZodEnum<["salesforce", "slack", "zendesk"]>;
    name: z.ZodString;
    status: z.ZodEnum<["connected", "disconnected", "error"]>;
    lastSyncAt: z.ZodNullable<z.ZodDate>;
    syncStatus: z.ZodNullable<z.ZodEnum<["success", "failed", "in_progress"]>>;
    syncError: z.ZodNullable<z.ZodString>;
    organizationId: z.ZodString;
} & {
    createdAt: z.ZodDate;
    updatedAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    type: "slack" | "salesforce" | "zendesk";
    status: "error" | "connected" | "disconnected";
    id: string;
    name: string;
    organizationId: string;
    createdAt: Date;
    updatedAt: Date;
    lastSyncAt: Date | null;
    syncStatus: "success" | "in_progress" | "failed" | null;
    syncError: string | null;
}, {
    type: "slack" | "salesforce" | "zendesk";
    status: "error" | "connected" | "disconnected";
    id: string;
    name: string;
    organizationId: string;
    createdAt: Date;
    updatedAt: Date;
    lastSyncAt: Date | null;
    syncStatus: "success" | "in_progress" | "failed" | null;
    syncError: string | null;
}>;
declare const createIntegrationSchema: z.ZodObject<{
    type: z.ZodEnum<["salesforce", "slack", "zendesk"]>;
    name: z.ZodString;
    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
    credentials: z.ZodRecord<z.ZodString, z.ZodUnknown>;
}, "strip", z.ZodTypeAny, {
    type: "slack" | "salesforce" | "zendesk";
    name: string;
    config: Record<string, unknown>;
    credentials: Record<string, unknown>;
}, {
    type: "slack" | "salesforce" | "zendesk";
    name: string;
    config: Record<string, unknown>;
    credentials: Record<string, unknown>;
}>;
declare const updateIntegrationSchema: z.ZodObject<{
    name: z.ZodOptional<z.ZodString>;
    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    credentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    name?: string | undefined;
    config?: Record<string, unknown> | undefined;
    credentials?: Record<string, unknown> | undefined;
}, {
    name?: string | undefined;
    config?: Record<string, unknown> | undefined;
    credentials?: Record<string, unknown> | undefined;
}>;
declare const webhookSchema: z.ZodObject<{
    id: z.ZodString;
    url: z.ZodString;
    events: z.ZodArray<z.ZodString, "many">;
    status: z.ZodEnum<["active", "paused", "failed"]>;
    lastTriggered: z.ZodNullable<z.ZodDate>;
    failureCount: z.ZodNumber;
    organizationId: z.ZodString;
} & {
    createdAt: z.ZodDate;
    updatedAt: z.ZodDate;
}, "strip", z.ZodTypeAny, {
    status: "active" | "failed" | "paused";
    id: string;
    organizationId: string;
    createdAt: Date;
    updatedAt: Date;
    url: string;
    events: string[];
    lastTriggered: Date | null;
    failureCount: number;
}, {
    status: "active" | "failed" | "paused";
    id: string;
    organizationId: string;
    createdAt: Date;
    updatedAt: Date;
    url: string;
    events: string[];
    lastTriggered: Date | null;
    failureCount: number;
}>;
declare const createWebhookSchema: z.ZodObject<{
    url: z.ZodString;
    events: z.ZodArray<z.ZodEnum<["conversation.created", "conversation.resolved", "conversation.escalated", "escalation.created", "escalation.assigned", "escalation.resolved", "agent.action.completed"]>, "many">;
}, "strip", z.ZodTypeAny, {
    url: string;
    events: ("conversation.created" | "conversation.resolved" | "conversation.escalated" | "escalation.created" | "escalation.assigned" | "escalation.resolved" | "agent.action.completed")[];
}, {
    url: string;
    events: ("conversation.created" | "conversation.resolved" | "conversation.escalated" | "escalation.created" | "escalation.assigned" | "escalation.resolved" | "agent.action.completed")[];
}>;
declare const updateWebhookSchema: z.ZodObject<{
    url: z.ZodOptional<z.ZodString>;
    events: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    status: z.ZodOptional<z.ZodEnum<["active", "paused", "failed"]>>;
}, "strip", z.ZodTypeAny, {
    status?: "active" | "failed" | "paused" | undefined;
    url?: string | undefined;
    events?: string[] | undefined;
}, {
    status?: "active" | "failed" | "paused" | undefined;
    url?: string | undefined;
    events?: string[] | undefined;
}>;
declare const webhookDeliverySchema: z.ZodObject<{
    id: z.ZodString;
    event: z.ZodString;
    status: z.ZodEnum<["pending", "delivered", "failed"]>;
    statusCode: z.ZodNullable<z.ZodNumber>;
    response: z.ZodNullable<z.ZodString>;
    attempts: z.ZodNumber;
    nextRetry: z.ZodNullable<z.ZodDate>;
    deliveredAt: z.ZodNullable<z.ZodDate>;
    createdAt: z.ZodDate;
    webhookId: z.ZodString;
}, "strip", z.ZodTypeAny, {
    status: "pending" | "failed" | "delivered";
    id: string;
    createdAt: Date;
    statusCode: number | null;
    event: string;
    response: string | null;
    attempts: number;
    nextRetry: Date | null;
    deliveredAt: Date | null;
    webhookId: string;
}, {
    status: "pending" | "failed" | "delivered";
    id: string;
    createdAt: Date;
    statusCode: number | null;
    event: string;
    response: string | null;
    attempts: number;
    nextRetry: Date | null;
    deliveredAt: Date | null;
    webhookId: string;
}>;
declare const testWebhookSchema: z.ZodObject<{
    event: z.ZodString;
    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
}, "strip", z.ZodTypeAny, {
    event: string;
    payload: Record<string, unknown>;
}, {
    event: string;
    payload: Record<string, unknown>;
}>;
type IntegrationType = z.infer<typeof integrationTypeEnum>;
type Integration = z.infer<typeof integrationSchema>;
type CreateIntegrationInput = z.infer<typeof createIntegrationSchema>;
type UpdateIntegrationInput = z.infer<typeof updateIntegrationSchema>;
type Webhook = z.infer<typeof webhookSchema>;
type CreateWebhookInput = z.infer<typeof createWebhookSchema>;
type UpdateWebhookInput = z.infer<typeof updateWebhookSchema>;
type WebhookDelivery = z.infer<typeof webhookDeliverySchema>;
type TestWebhookInput = z.infer<typeof testWebhookSchema>;

declare const authContract: {
    login: {
        summary: "Login with email and password";
        method: "POST";
        body: z.ZodObject<{
            email: z.ZodString;
            password: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            email: string;
            password: string;
        }, {
            email: string;
            password: string;
        }>;
        path: "/auth/login";
        responses: {
            200: z.ZodObject<{
                accessToken: z.ZodString;
                refreshToken: z.ZodString;
                expiresIn: z.ZodNumber;
                user: z.ZodObject<{
                    id: z.ZodString;
                    email: z.ZodString;
                    name: z.ZodString;
                    role: z.ZodEnum<["admin", "agent", "viewer"]>;
                    organizationId: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    email: string;
                    id: string;
                    name: string;
                    role: "admin" | "agent" | "viewer";
                    organizationId: string;
                }, {
                    email: string;
                    id: string;
                    name: string;
                    role: "admin" | "agent" | "viewer";
                    organizationId: string;
                }>;
            }, "strip", z.ZodTypeAny, {
                accessToken: string;
                refreshToken: string;
                expiresIn: number;
                user: {
                    email: string;
                    id: string;
                    name: string;
                    role: "admin" | "agent" | "viewer";
                    organizationId: string;
                };
            }, {
                accessToken: string;
                refreshToken: string;
                expiresIn: number;
                user: {
                    email: string;
                    id: string;
                    name: string;
                    role: "admin" | "agent" | "viewer";
                    organizationId: string;
                };
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    register: {
        summary: "Register a new organization and admin user";
        method: "POST";
        body: z.ZodObject<{
            email: z.ZodString;
            password: z.ZodString;
            name: z.ZodString;
            organizationName: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            email: string;
            password: string;
            name: string;
            organizationName: string;
        }, {
            email: string;
            password: string;
            name: string;
            organizationName: string;
        }>;
        path: "/auth/register";
        responses: {
            201: z.ZodObject<{
                accessToken: z.ZodString;
                refreshToken: z.ZodString;
                expiresIn: z.ZodNumber;
                user: z.ZodObject<{
                    id: z.ZodString;
                    email: z.ZodString;
                    name: z.ZodString;
                    role: z.ZodEnum<["admin", "agent", "viewer"]>;
                    organizationId: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    email: string;
                    id: string;
                    name: string;
                    role: "admin" | "agent" | "viewer";
                    organizationId: string;
                }, {
                    email: string;
                    id: string;
                    name: string;
                    role: "admin" | "agent" | "viewer";
                    organizationId: string;
                }>;
            }, "strip", z.ZodTypeAny, {
                accessToken: string;
                refreshToken: string;
                expiresIn: number;
                user: {
                    email: string;
                    id: string;
                    name: string;
                    role: "admin" | "agent" | "viewer";
                    organizationId: string;
                };
            }, {
                accessToken: string;
                refreshToken: string;
                expiresIn: number;
                user: {
                    email: string;
                    id: string;
                    name: string;
                    role: "admin" | "agent" | "viewer";
                    organizationId: string;
                };
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            409: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    refreshToken: {
        summary: "Refresh access token";
        method: "POST";
        body: z.ZodObject<{
            refreshToken: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            refreshToken: string;
        }, {
            refreshToken: string;
        }>;
        path: "/auth/refresh";
        responses: {
            200: z.ZodObject<{
                accessToken: z.ZodString;
                expiresIn: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                accessToken: string;
                expiresIn: number;
            }, {
                accessToken: string;
                expiresIn: number;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    changePassword: {
        summary: "Change user password";
        method: "POST";
        body: z.ZodObject<{
            currentPassword: z.ZodString;
            newPassword: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            currentPassword: string;
            newPassword: string;
        }, {
            currentPassword: string;
            newPassword: string;
        }>;
        path: "/auth/change-password";
        responses: {
            200: z.ZodObject<{
                message: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                message: string;
            }, {
                message: string;
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    createApiKey: {
        summary: "Create a new API key";
        method: "POST";
        body: z.ZodObject<{
            name: z.ZodString;
            permissions: z.ZodArray<z.ZodString, "many">;
            expiresAt: z.ZodOptional<z.ZodDate>;
        }, "strip", z.ZodTypeAny, {
            name: string;
            permissions: string[];
            expiresAt?: Date | undefined;
        }, {
            name: string;
            permissions: string[];
            expiresAt?: Date | undefined;
        }>;
        path: "/auth/api-keys";
        responses: {
            201: z.ZodObject<{
                id: z.ZodString;
                name: z.ZodString;
                key: z.ZodString;
                keyPrefix: z.ZodString;
                permissions: z.ZodArray<z.ZodString, "many">;
                expiresAt: z.ZodNullable<z.ZodDate>;
                lastUsedAt: z.ZodNullable<z.ZodDate>;
            } & {
                createdAt: z.ZodDate;
                updatedAt: z.ZodDate;
            }, "strip", z.ZodTypeAny, {
                id: string;
                name: string;
                permissions: string[];
                expiresAt: Date | null;
                key: string;
                keyPrefix: string;
                lastUsedAt: Date | null;
                createdAt: Date;
                updatedAt: Date;
            }, {
                id: string;
                name: string;
                permissions: string[];
                expiresAt: Date | null;
                key: string;
                keyPrefix: string;
                lastUsedAt: Date | null;
                createdAt: Date;
                updatedAt: Date;
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    listApiKeys: {
        summary: "List all API keys";
        method: "GET";
        path: "/auth/api-keys";
        responses: {
            200: z.ZodObject<{
                apiKeys: z.ZodArray<z.ZodObject<{
                    id: z.ZodString;
                    name: z.ZodString;
                    keyPrefix: z.ZodString;
                    permissions: z.ZodArray<z.ZodString, "many">;
                    expiresAt: z.ZodNullable<z.ZodDate>;
                    lastUsedAt: z.ZodNullable<z.ZodDate>;
                } & {
                    createdAt: z.ZodDate;
                    updatedAt: z.ZodDate;
                }, "strip", z.ZodTypeAny, {
                    id: string;
                    name: string;
                    permissions: string[];
                    expiresAt: Date | null;
                    keyPrefix: string;
                    lastUsedAt: Date | null;
                    createdAt: Date;
                    updatedAt: Date;
                }, {
                    id: string;
                    name: string;
                    permissions: string[];
                    expiresAt: Date | null;
                    keyPrefix: string;
                    lastUsedAt: Date | null;
                    createdAt: Date;
                    updatedAt: Date;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                apiKeys: {
                    id: string;
                    name: string;
                    permissions: string[];
                    expiresAt: Date | null;
                    keyPrefix: string;
                    lastUsedAt: Date | null;
                    createdAt: Date;
                    updatedAt: Date;
                }[];
            }, {
                apiKeys: {
                    id: string;
                    name: string;
                    permissions: string[];
                    expiresAt: Date | null;
                    keyPrefix: string;
                    lastUsedAt: Date | null;
                    createdAt: Date;
                    updatedAt: Date;
                }[];
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    deleteApiKey: {
        pathParams: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        summary: "Delete an API key";
        method: "DELETE";
        body: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
        path: "/auth/api-keys/:id";
        responses: {
            200: z.ZodObject<{
                message: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                message: string;
            }, {
                message: string;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    createPublicApiKey: {
        summary: "Create a public API key for frontend SDK";
        method: "POST";
        body: z.ZodObject<{
            name: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            name?: string | undefined;
        }, {
            name?: string | undefined;
        }>;
        path: "/auth/public-api-keys";
        responses: {
            201: z.ZodObject<{
                id: z.ZodString;
                name: z.ZodString;
                key: z.ZodString;
                keyPrefix: z.ZodString;
                permissions: z.ZodArray<z.ZodString, "many">;
                expiresAt: z.ZodNullable<z.ZodDate>;
                lastUsedAt: z.ZodNullable<z.ZodDate>;
            } & {
                createdAt: z.ZodDate;
                updatedAt: z.ZodDate;
            }, "strip", z.ZodTypeAny, {
                id: string;
                name: string;
                permissions: string[];
                expiresAt: Date | null;
                key: string;
                keyPrefix: string;
                lastUsedAt: Date | null;
                createdAt: Date;
                updatedAt: Date;
            }, {
                id: string;
                name: string;
                permissions: string[];
                expiresAt: Date | null;
                key: string;
                keyPrefix: string;
                lastUsedAt: Date | null;
                createdAt: Date;
                updatedAt: Date;
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
};

declare const publicContract: {
    identify: {
        summary: "Identify user for persistent memory (frontend SDK)";
        method: "POST";
        body: z.ZodObject<{
            userId: z.ZodString;
            userData: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, "strip", z.ZodTypeAny, {
            userId: string;
            userData?: Record<string, unknown> | undefined;
        }, {
            userId: string;
            userData?: Record<string, unknown> | undefined;
        }>;
        path: "/public/identify";
        responses: {
            200: z.ZodObject<{
                message: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                message: string;
            }, {
                message: string;
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
};

declare const knowledgeContract: {
    uploadDocument: {
        summary: "Upload a knowledge document (PDF, Markdown, or Text)";
        method: "POST";
        contentType: "multipart/form-data";
        body: z.ZodObject<{
            documentId: z.ZodString;
            agentType: z.ZodOptional<z.ZodString>;
            file: z.ZodAny;
        }, "strip", z.ZodTypeAny, {
            documentId: string;
            agentType?: string | undefined;
            file?: any;
        }, {
            documentId: string;
            agentType?: string | undefined;
            file?: any;
        }>;
        path: "/knowledge/upload";
        responses: {
            201: z.ZodObject<{
                id: z.ZodString;
                documentId: z.ZodString;
                filename: z.ZodString;
                contentType: z.ZodString;
                agentType: z.ZodNullable<z.ZodString>;
                fileSize: z.ZodNumber;
                chunkCount: z.ZodNumber;
                status: z.ZodString;
                uploadedAt: z.ZodDate;
                processedAt: z.ZodNullable<z.ZodDate>;
            }, "strip", z.ZodTypeAny, {
                contentType: string;
                status: string;
                id: string;
                documentId: string;
                agentType: string | null;
                filename: string;
                fileSize: number;
                chunkCount: number;
                uploadedAt: Date;
                processedAt: Date | null;
            }, {
                contentType: string;
                status: string;
                id: string;
                documentId: string;
                agentType: string | null;
                filename: string;
                fileSize: number;
                chunkCount: number;
                uploadedAt: Date;
                processedAt: Date | null;
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    listDocuments: {
        query: z.ZodObject<{
            agentType: z.ZodOptional<z.ZodString>;
            status: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            status?: string | undefined;
            agentType?: string | undefined;
        }, {
            status?: string | undefined;
            agentType?: string | undefined;
        }>;
        summary: "List knowledge documents";
        method: "GET";
        path: "/knowledge/documents";
        responses: {
            200: z.ZodObject<{
                documents: z.ZodArray<z.ZodObject<{
                    id: z.ZodString;
                    documentId: z.ZodString;
                    filename: z.ZodString;
                    contentType: z.ZodString;
                    agentType: z.ZodNullable<z.ZodString>;
                    fileSize: z.ZodNumber;
                    chunkCount: z.ZodNumber;
                    status: z.ZodString;
                    uploadedAt: z.ZodDate;
                    processedAt: z.ZodNullable<z.ZodDate>;
                }, "strip", z.ZodTypeAny, {
                    contentType: string;
                    status: string;
                    id: string;
                    documentId: string;
                    agentType: string | null;
                    filename: string;
                    fileSize: number;
                    chunkCount: number;
                    uploadedAt: Date;
                    processedAt: Date | null;
                }, {
                    contentType: string;
                    status: string;
                    id: string;
                    documentId: string;
                    agentType: string | null;
                    filename: string;
                    fileSize: number;
                    chunkCount: number;
                    uploadedAt: Date;
                    processedAt: Date | null;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                documents: {
                    contentType: string;
                    status: string;
                    id: string;
                    documentId: string;
                    agentType: string | null;
                    filename: string;
                    fileSize: number;
                    chunkCount: number;
                    uploadedAt: Date;
                    processedAt: Date | null;
                }[];
            }, {
                documents: {
                    contentType: string;
                    status: string;
                    id: string;
                    documentId: string;
                    agentType: string | null;
                    filename: string;
                    fileSize: number;
                    chunkCount: number;
                    uploadedAt: Date;
                    processedAt: Date | null;
                }[];
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    getDocument: {
        pathParams: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        summary: "Get knowledge document by ID";
        method: "GET";
        path: "/knowledge/documents/:id";
        responses: {
            200: z.ZodObject<{
                id: z.ZodString;
                documentId: z.ZodString;
                filename: z.ZodString;
                contentType: z.ZodString;
                agentType: z.ZodNullable<z.ZodString>;
                fileSize: z.ZodNumber;
                chunkCount: z.ZodNumber;
                status: z.ZodString;
                uploadedAt: z.ZodDate;
                processedAt: z.ZodNullable<z.ZodDate>;
            }, "strip", z.ZodTypeAny, {
                contentType: string;
                status: string;
                id: string;
                documentId: string;
                agentType: string | null;
                filename: string;
                fileSize: number;
                chunkCount: number;
                uploadedAt: Date;
                processedAt: Date | null;
            }, {
                contentType: string;
                status: string;
                id: string;
                documentId: string;
                agentType: string | null;
                filename: string;
                fileSize: number;
                chunkCount: number;
                uploadedAt: Date;
                processedAt: Date | null;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    deleteDocument: {
        pathParams: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        summary: "Delete knowledge document and all its chunks";
        method: "DELETE";
        body: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
        path: "/knowledge/documents/:id";
        responses: {
            200: z.ZodObject<{
                message: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                message: string;
            }, {
                message: string;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    updateDocumentAgent: {
        pathParams: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        summary: "Update document agent assignment";
        method: "PATCH";
        body: z.ZodObject<{
            agentType: z.ZodNullable<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            agentType: string | null;
        }, {
            agentType: string | null;
        }>;
        path: "/knowledge/documents/:id/agent";
        responses: {
            200: z.ZodObject<{
                id: z.ZodString;
                documentId: z.ZodString;
                filename: z.ZodString;
                contentType: z.ZodString;
                agentType: z.ZodNullable<z.ZodString>;
                fileSize: z.ZodNumber;
                chunkCount: z.ZodNumber;
                status: z.ZodString;
                uploadedAt: z.ZodDate;
                processedAt: z.ZodNullable<z.ZodDate>;
            }, "strip", z.ZodTypeAny, {
                contentType: string;
                status: string;
                id: string;
                documentId: string;
                agentType: string | null;
                filename: string;
                fileSize: number;
                chunkCount: number;
                uploadedAt: Date;
                processedAt: Date | null;
            }, {
                contentType: string;
                status: string;
                id: string;
                documentId: string;
                agentType: string | null;
                filename: string;
                fileSize: number;
                chunkCount: number;
                uploadedAt: Date;
                processedAt: Date | null;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
};

declare const toolsContract: {
    createTool: {
        summary: "Register a new external tool";
        method: "POST";
        body: z.ZodObject<{
            name: z.ZodString;
            description: z.ZodString;
            endpointUrl: z.ZodString;
            httpMethod: z.ZodOptional<z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>>;
            bodySchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            agentType: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            description: string;
            name: string;
            endpointUrl: string;
            bodySchema: Record<string, unknown>;
            headers?: Record<string, string> | undefined;
            agentType?: string | undefined;
            httpMethod?: "GET" | "POST" | "DELETE" | "PUT" | "PATCH" | undefined;
        }, {
            description: string;
            name: string;
            endpointUrl: string;
            bodySchema: Record<string, unknown>;
            headers?: Record<string, string> | undefined;
            agentType?: string | undefined;
            httpMethod?: "GET" | "POST" | "DELETE" | "PUT" | "PATCH" | undefined;
        }>;
        path: "/tools";
        responses: {
            201: z.ZodObject<{
                id: z.ZodString;
                name: z.ZodString;
                description: z.ZodString;
                agentType: z.ZodNullable<z.ZodString>;
                endpointUrl: z.ZodString;
                httpMethod: z.ZodString;
                bodySchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
                headers: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
                enabled: z.ZodBoolean;
                createdAt: z.ZodDate;
                updatedAt: z.ZodDate;
            }, "strip", z.ZodTypeAny, {
                headers: Record<string, string> | null;
                description: string;
                id: string;
                name: string;
                createdAt: Date;
                updatedAt: Date;
                agentType: string | null;
                endpointUrl: string;
                httpMethod: string;
                bodySchema: Record<string, unknown>;
                enabled: boolean;
            }, {
                headers: Record<string, string> | null;
                description: string;
                id: string;
                name: string;
                createdAt: Date;
                updatedAt: Date;
                agentType: string | null;
                endpointUrl: string;
                httpMethod: string;
                bodySchema: Record<string, unknown>;
                enabled: boolean;
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    listTools: {
        query: z.ZodObject<{
            agentType: z.ZodOptional<z.ZodString>;
            enabled: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            agentType?: string | undefined;
            enabled?: string | undefined;
        }, {
            agentType?: string | undefined;
            enabled?: string | undefined;
        }>;
        summary: "List all registered tools";
        method: "GET";
        path: "/tools";
        responses: {
            200: z.ZodObject<{
                tools: z.ZodArray<z.ZodObject<{
                    id: z.ZodString;
                    name: z.ZodString;
                    description: z.ZodString;
                    agentType: z.ZodNullable<z.ZodString>;
                    endpointUrl: z.ZodString;
                    httpMethod: z.ZodString;
                    bodySchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
                    headers: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
                    enabled: z.ZodBoolean;
                    createdAt: z.ZodDate;
                    updatedAt: z.ZodDate;
                }, "strip", z.ZodTypeAny, {
                    headers: Record<string, string> | null;
                    description: string;
                    id: string;
                    name: string;
                    createdAt: Date;
                    updatedAt: Date;
                    agentType: string | null;
                    endpointUrl: string;
                    httpMethod: string;
                    bodySchema: Record<string, unknown>;
                    enabled: boolean;
                }, {
                    headers: Record<string, string> | null;
                    description: string;
                    id: string;
                    name: string;
                    createdAt: Date;
                    updatedAt: Date;
                    agentType: string | null;
                    endpointUrl: string;
                    httpMethod: string;
                    bodySchema: Record<string, unknown>;
                    enabled: boolean;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                tools: {
                    headers: Record<string, string> | null;
                    description: string;
                    id: string;
                    name: string;
                    createdAt: Date;
                    updatedAt: Date;
                    agentType: string | null;
                    endpointUrl: string;
                    httpMethod: string;
                    bodySchema: Record<string, unknown>;
                    enabled: boolean;
                }[];
            }, {
                tools: {
                    headers: Record<string, string> | null;
                    description: string;
                    id: string;
                    name: string;
                    createdAt: Date;
                    updatedAt: Date;
                    agentType: string | null;
                    endpointUrl: string;
                    httpMethod: string;
                    bodySchema: Record<string, unknown>;
                    enabled: boolean;
                }[];
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    getTool: {
        pathParams: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        summary: "Get tool by ID";
        method: "GET";
        path: "/tools/:id";
        responses: {
            200: z.ZodObject<{
                id: z.ZodString;
                name: z.ZodString;
                description: z.ZodString;
                agentType: z.ZodNullable<z.ZodString>;
                endpointUrl: z.ZodString;
                httpMethod: z.ZodString;
                bodySchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
                headers: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
                enabled: z.ZodBoolean;
                createdAt: z.ZodDate;
                updatedAt: z.ZodDate;
            }, "strip", z.ZodTypeAny, {
                headers: Record<string, string> | null;
                description: string;
                id: string;
                name: string;
                createdAt: Date;
                updatedAt: Date;
                agentType: string | null;
                endpointUrl: string;
                httpMethod: string;
                bodySchema: Record<string, unknown>;
                enabled: boolean;
            }, {
                headers: Record<string, string> | null;
                description: string;
                id: string;
                name: string;
                createdAt: Date;
                updatedAt: Date;
                agentType: string | null;
                endpointUrl: string;
                httpMethod: string;
                bodySchema: Record<string, unknown>;
                enabled: boolean;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    updateTool: {
        pathParams: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        summary: "Update tool configuration";
        method: "PATCH";
        body: z.ZodObject<{
            name: z.ZodOptional<z.ZodString>;
            description: z.ZodOptional<z.ZodString>;
            endpointUrl: z.ZodOptional<z.ZodString>;
            httpMethod: z.ZodOptional<z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>>;
            bodySchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            agentType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            enabled: z.ZodOptional<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            headers?: Record<string, string> | undefined;
            description?: string | undefined;
            name?: string | undefined;
            agentType?: string | null | undefined;
            endpointUrl?: string | undefined;
            httpMethod?: "GET" | "POST" | "DELETE" | "PUT" | "PATCH" | undefined;
            bodySchema?: Record<string, unknown> | undefined;
            enabled?: boolean | undefined;
        }, {
            headers?: Record<string, string> | undefined;
            description?: string | undefined;
            name?: string | undefined;
            agentType?: string | null | undefined;
            endpointUrl?: string | undefined;
            httpMethod?: "GET" | "POST" | "DELETE" | "PUT" | "PATCH" | undefined;
            bodySchema?: Record<string, unknown> | undefined;
            enabled?: boolean | undefined;
        }>;
        path: "/tools/:id";
        responses: {
            200: z.ZodObject<{
                id: z.ZodString;
                name: z.ZodString;
                description: z.ZodString;
                agentType: z.ZodNullable<z.ZodString>;
                endpointUrl: z.ZodString;
                httpMethod: z.ZodString;
                bodySchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
                headers: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
                enabled: z.ZodBoolean;
                createdAt: z.ZodDate;
                updatedAt: z.ZodDate;
            }, "strip", z.ZodTypeAny, {
                headers: Record<string, string> | null;
                description: string;
                id: string;
                name: string;
                createdAt: Date;
                updatedAt: Date;
                agentType: string | null;
                endpointUrl: string;
                httpMethod: string;
                bodySchema: Record<string, unknown>;
                enabled: boolean;
            }, {
                headers: Record<string, string> | null;
                description: string;
                id: string;
                name: string;
                createdAt: Date;
                updatedAt: Date;
                agentType: string | null;
                endpointUrl: string;
                httpMethod: string;
                bodySchema: Record<string, unknown>;
                enabled: boolean;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    deleteTool: {
        pathParams: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        summary: "Delete a tool";
        method: "DELETE";
        body: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
        path: "/tools/:id";
        responses: {
            200: z.ZodObject<{
                message: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                message: string;
            }, {
                message: string;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    executeTool: {
        pathParams: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        summary: "Execute a registered tool";
        method: "POST";
        body: z.ZodObject<{
            body: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, "strip", z.ZodTypeAny, {
            body?: Record<string, unknown> | undefined;
        }, {
            body?: Record<string, unknown> | undefined;
        }>;
        path: "/tools/:id/execute";
        responses: {
            200: z.ZodObject<{
                success: z.ZodBoolean;
                statusCode: z.ZodNumber;
                data: z.ZodOptional<z.ZodUnknown>;
                error: z.ZodOptional<z.ZodString>;
            }, "strip", z.ZodTypeAny, {
                success: boolean;
                statusCode: number;
                data?: unknown;
                error?: string | undefined;
            }, {
                success: boolean;
                statusCode: number;
                data?: unknown;
                error?: string | undefined;
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            500: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
};

declare const conversationsContract: {
    createConversation: {
        summary: "Create a new conversation";
        method: "POST";
        body: z.ZodObject<{
            customerId: z.ZodString;
            customerEmail: z.ZodOptional<z.ZodString>;
            customerName: z.ZodOptional<z.ZodString>;
            channel: z.ZodDefault<z.ZodEnum<["web", "mobile", "email", "slack", "api"]>>;
            priority: z.ZodDefault<z.ZodEnum<["low", "normal", "high", "urgent"]>>;
            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, "strip", z.ZodTypeAny, {
            customerId: string;
            channel: "email" | "web" | "mobile" | "slack" | "api";
            priority: "low" | "normal" | "high" | "urgent";
            metadata?: Record<string, unknown> | undefined;
            customerEmail?: string | undefined;
            customerName?: string | undefined;
        }, {
            customerId: string;
            metadata?: Record<string, unknown> | undefined;
            customerEmail?: string | undefined;
            customerName?: string | undefined;
            channel?: "email" | "web" | "mobile" | "slack" | "api" | undefined;
            priority?: "low" | "normal" | "high" | "urgent" | undefined;
        }>;
        path: "/conversations";
        responses: {
            201: z.ZodObject<{
                id: z.ZodString;
                customerId: z.ZodString;
                customerEmail: z.ZodNullable<z.ZodString>;
                customerName: z.ZodNullable<z.ZodString>;
                channel: z.ZodEnum<["web", "mobile", "email", "slack", "api"]>;
                status: z.ZodEnum<["active", "resolved", "escalated"]>;
                priority: z.ZodEnum<["low", "normal", "high", "urgent"]>;
                sentiment: z.ZodEnum<["positive", "neutral", "negative", "frustrated", "angry"]>;
                effortScore: z.ZodNullable<z.ZodNumber>;
                resolved: z.ZodBoolean;
                resolvedAt: z.ZodNullable<z.ZodDate>;
                firstResponseAt: z.ZodNullable<z.ZodDate>;
                contextSummary: z.ZodNullable<z.ZodString>;
                metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                organizationId: z.ZodString;
            } & {
                createdAt: z.ZodDate;
                updatedAt: z.ZodDate;
            }, "strip", z.ZodTypeAny, {
                metadata: Record<string, unknown> | null;
                status: "active" | "resolved" | "escalated";
                id: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                customerId: string;
                customerEmail: string | null;
                customerName: string | null;
                channel: "email" | "web" | "mobile" | "slack" | "api";
                priority: "low" | "normal" | "high" | "urgent";
                resolved: boolean;
                sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
                effortScore: number | null;
                resolvedAt: Date | null;
                firstResponseAt: Date | null;
                contextSummary: string | null;
            }, {
                metadata: Record<string, unknown> | null;
                status: "active" | "resolved" | "escalated";
                id: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                customerId: string;
                customerEmail: string | null;
                customerName: string | null;
                channel: "email" | "web" | "mobile" | "slack" | "api";
                priority: "low" | "normal" | "high" | "urgent";
                resolved: boolean;
                sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
                effortScore: number | null;
                resolvedAt: Date | null;
                firstResponseAt: Date | null;
                contextSummary: string | null;
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    getConversation: {
        pathParams: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        summary: "Get conversation by ID with messages";
        method: "GET";
        path: "/conversations/:id";
        responses: {
            200: z.ZodObject<{
                id: z.ZodString;
                customerId: z.ZodString;
                customerEmail: z.ZodNullable<z.ZodString>;
                customerName: z.ZodNullable<z.ZodString>;
                channel: z.ZodEnum<["web", "mobile", "email", "slack", "api"]>;
                status: z.ZodEnum<["active", "resolved", "escalated"]>;
                priority: z.ZodEnum<["low", "normal", "high", "urgent"]>;
                sentiment: z.ZodEnum<["positive", "neutral", "negative", "frustrated", "angry"]>;
                effortScore: z.ZodNullable<z.ZodNumber>;
                resolved: z.ZodBoolean;
                resolvedAt: z.ZodNullable<z.ZodDate>;
                firstResponseAt: z.ZodNullable<z.ZodDate>;
                contextSummary: z.ZodNullable<z.ZodString>;
                metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                organizationId: z.ZodString;
            } & {
                createdAt: z.ZodDate;
                updatedAt: z.ZodDate;
            } & {
                messages: z.ZodArray<z.ZodObject<{
                    id: z.ZodString;
                    content: z.ZodString;
                    role: z.ZodEnum<["user", "assistant", "system"]>;
                    agentType: z.ZodNullable<z.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>>;
                    tokenCount: z.ZodNumber;
                    cost: z.ZodNumber;
                    sentiment: z.ZodNullable<z.ZodEnum<["positive", "neutral", "negative", "frustrated", "angry"]>>;
                    intent: z.ZodNullable<z.ZodString>;
                    metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                } & {
                    createdAt: z.ZodDate;
                    updatedAt: z.ZodDate;
                }, "strip", z.ZodTypeAny, {
                    metadata: Record<string, unknown> | null;
                    id: string;
                    role: "user" | "assistant" | "system";
                    createdAt: Date;
                    updatedAt: Date;
                    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | null;
                    sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry" | null;
                    content: string;
                    tokenCount: number;
                    cost: number;
                    intent: string | null;
                }, {
                    metadata: Record<string, unknown> | null;
                    id: string;
                    role: "user" | "assistant" | "system";
                    createdAt: Date;
                    updatedAt: Date;
                    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | null;
                    sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry" | null;
                    content: string;
                    tokenCount: number;
                    cost: number;
                    intent: string | null;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                metadata: Record<string, unknown> | null;
                status: "active" | "resolved" | "escalated";
                id: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                customerId: string;
                customerEmail: string | null;
                customerName: string | null;
                channel: "email" | "web" | "mobile" | "slack" | "api";
                priority: "low" | "normal" | "high" | "urgent";
                resolved: boolean;
                sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
                effortScore: number | null;
                resolvedAt: Date | null;
                firstResponseAt: Date | null;
                contextSummary: string | null;
                messages: {
                    metadata: Record<string, unknown> | null;
                    id: string;
                    role: "user" | "assistant" | "system";
                    createdAt: Date;
                    updatedAt: Date;
                    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | null;
                    sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry" | null;
                    content: string;
                    tokenCount: number;
                    cost: number;
                    intent: string | null;
                }[];
            }, {
                metadata: Record<string, unknown> | null;
                status: "active" | "resolved" | "escalated";
                id: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                customerId: string;
                customerEmail: string | null;
                customerName: string | null;
                channel: "email" | "web" | "mobile" | "slack" | "api";
                priority: "low" | "normal" | "high" | "urgent";
                resolved: boolean;
                sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
                effortScore: number | null;
                resolvedAt: Date | null;
                firstResponseAt: Date | null;
                contextSummary: string | null;
                messages: {
                    metadata: Record<string, unknown> | null;
                    id: string;
                    role: "user" | "assistant" | "system";
                    createdAt: Date;
                    updatedAt: Date;
                    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | null;
                    sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry" | null;
                    content: string;
                    tokenCount: number;
                    cost: number;
                    intent: string | null;
                }[];
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    listConversations: {
        query: z.ZodObject<{
            page: z.ZodDefault<z.ZodNumber>;
            limit: z.ZodDefault<z.ZodNumber>;
        } & {
            status: z.ZodOptional<z.ZodEnum<["active", "resolved", "escalated"]>>;
            priority: z.ZodOptional<z.ZodEnum<["low", "normal", "high", "urgent"]>>;
            channel: z.ZodOptional<z.ZodEnum<["web", "mobile", "email", "slack", "api"]>>;
            customerId: z.ZodOptional<z.ZodString>;
            fromDate: z.ZodOptional<z.ZodDate>;
            toDate: z.ZodOptional<z.ZodDate>;
        }, "strip", z.ZodTypeAny, {
            page: number;
            limit: number;
            status?: "active" | "resolved" | "escalated" | undefined;
            customerId?: string | undefined;
            channel?: "email" | "web" | "mobile" | "slack" | "api" | undefined;
            priority?: "low" | "normal" | "high" | "urgent" | undefined;
            fromDate?: Date | undefined;
            toDate?: Date | undefined;
        }, {
            status?: "active" | "resolved" | "escalated" | undefined;
            customerId?: string | undefined;
            channel?: "email" | "web" | "mobile" | "slack" | "api" | undefined;
            priority?: "low" | "normal" | "high" | "urgent" | undefined;
            page?: number | undefined;
            limit?: number | undefined;
            fromDate?: Date | undefined;
            toDate?: Date | undefined;
        }>;
        summary: "List conversations with pagination and filters";
        method: "GET";
        path: "/conversations";
        responses: {
            200: z.ZodObject<{
                conversations: z.ZodArray<z.ZodObject<{
                    id: z.ZodString;
                    customerId: z.ZodString;
                    customerEmail: z.ZodNullable<z.ZodString>;
                    customerName: z.ZodNullable<z.ZodString>;
                    channel: z.ZodEnum<["web", "mobile", "email", "slack", "api"]>;
                    status: z.ZodEnum<["active", "resolved", "escalated"]>;
                    priority: z.ZodEnum<["low", "normal", "high", "urgent"]>;
                    sentiment: z.ZodEnum<["positive", "neutral", "negative", "frustrated", "angry"]>;
                    effortScore: z.ZodNullable<z.ZodNumber>;
                    resolved: z.ZodBoolean;
                    resolvedAt: z.ZodNullable<z.ZodDate>;
                    firstResponseAt: z.ZodNullable<z.ZodDate>;
                    contextSummary: z.ZodNullable<z.ZodString>;
                    metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                    organizationId: z.ZodString;
                } & {
                    createdAt: z.ZodDate;
                    updatedAt: z.ZodDate;
                }, "strip", z.ZodTypeAny, {
                    metadata: Record<string, unknown> | null;
                    status: "active" | "resolved" | "escalated";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    customerId: string;
                    customerEmail: string | null;
                    customerName: string | null;
                    channel: "email" | "web" | "mobile" | "slack" | "api";
                    priority: "low" | "normal" | "high" | "urgent";
                    resolved: boolean;
                    sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
                    effortScore: number | null;
                    resolvedAt: Date | null;
                    firstResponseAt: Date | null;
                    contextSummary: string | null;
                }, {
                    metadata: Record<string, unknown> | null;
                    status: "active" | "resolved" | "escalated";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    customerId: string;
                    customerEmail: string | null;
                    customerName: string | null;
                    channel: "email" | "web" | "mobile" | "slack" | "api";
                    priority: "low" | "normal" | "high" | "urgent";
                    resolved: boolean;
                    sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
                    effortScore: number | null;
                    resolvedAt: Date | null;
                    firstResponseAt: Date | null;
                    contextSummary: string | null;
                }>, "many">;
                pagination: z.ZodObject<{
                    page: z.ZodNumber;
                    limit: z.ZodNumber;
                    total: z.ZodNumber;
                    totalPages: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    page: number;
                    limit: number;
                    total: number;
                    totalPages: number;
                }, {
                    page: number;
                    limit: number;
                    total: number;
                    totalPages: number;
                }>;
            }, "strip", z.ZodTypeAny, {
                conversations: {
                    metadata: Record<string, unknown> | null;
                    status: "active" | "resolved" | "escalated";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    customerId: string;
                    customerEmail: string | null;
                    customerName: string | null;
                    channel: "email" | "web" | "mobile" | "slack" | "api";
                    priority: "low" | "normal" | "high" | "urgent";
                    resolved: boolean;
                    sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
                    effortScore: number | null;
                    resolvedAt: Date | null;
                    firstResponseAt: Date | null;
                    contextSummary: string | null;
                }[];
                pagination: {
                    page: number;
                    limit: number;
                    total: number;
                    totalPages: number;
                };
            }, {
                conversations: {
                    metadata: Record<string, unknown> | null;
                    status: "active" | "resolved" | "escalated";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    customerId: string;
                    customerEmail: string | null;
                    customerName: string | null;
                    channel: "email" | "web" | "mobile" | "slack" | "api";
                    priority: "low" | "normal" | "high" | "urgent";
                    resolved: boolean;
                    sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
                    effortScore: number | null;
                    resolvedAt: Date | null;
                    firstResponseAt: Date | null;
                    contextSummary: string | null;
                }[];
                pagination: {
                    page: number;
                    limit: number;
                    total: number;
                    totalPages: number;
                };
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    updateConversation: {
        pathParams: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        summary: "Update conversation";
        method: "PATCH";
        body: z.ZodObject<{
            status: z.ZodOptional<z.ZodEnum<["active", "resolved", "escalated"]>>;
            priority: z.ZodOptional<z.ZodEnum<["low", "normal", "high", "urgent"]>>;
            effortScore: z.ZodOptional<z.ZodNumber>;
            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, "strip", z.ZodTypeAny, {
            metadata?: Record<string, unknown> | undefined;
            status?: "active" | "resolved" | "escalated" | undefined;
            priority?: "low" | "normal" | "high" | "urgent" | undefined;
            effortScore?: number | undefined;
        }, {
            metadata?: Record<string, unknown> | undefined;
            status?: "active" | "resolved" | "escalated" | undefined;
            priority?: "low" | "normal" | "high" | "urgent" | undefined;
            effortScore?: number | undefined;
        }>;
        path: "/conversations/:id";
        responses: {
            200: z.ZodObject<{
                id: z.ZodString;
                customerId: z.ZodString;
                customerEmail: z.ZodNullable<z.ZodString>;
                customerName: z.ZodNullable<z.ZodString>;
                channel: z.ZodEnum<["web", "mobile", "email", "slack", "api"]>;
                status: z.ZodEnum<["active", "resolved", "escalated"]>;
                priority: z.ZodEnum<["low", "normal", "high", "urgent"]>;
                sentiment: z.ZodEnum<["positive", "neutral", "negative", "frustrated", "angry"]>;
                effortScore: z.ZodNullable<z.ZodNumber>;
                resolved: z.ZodBoolean;
                resolvedAt: z.ZodNullable<z.ZodDate>;
                firstResponseAt: z.ZodNullable<z.ZodDate>;
                contextSummary: z.ZodNullable<z.ZodString>;
                metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                organizationId: z.ZodString;
            } & {
                createdAt: z.ZodDate;
                updatedAt: z.ZodDate;
            }, "strip", z.ZodTypeAny, {
                metadata: Record<string, unknown> | null;
                status: "active" | "resolved" | "escalated";
                id: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                customerId: string;
                customerEmail: string | null;
                customerName: string | null;
                channel: "email" | "web" | "mobile" | "slack" | "api";
                priority: "low" | "normal" | "high" | "urgent";
                resolved: boolean;
                sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
                effortScore: number | null;
                resolvedAt: Date | null;
                firstResponseAt: Date | null;
                contextSummary: string | null;
            }, {
                metadata: Record<string, unknown> | null;
                status: "active" | "resolved" | "escalated";
                id: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                customerId: string;
                customerEmail: string | null;
                customerName: string | null;
                channel: "email" | "web" | "mobile" | "slack" | "api";
                priority: "low" | "normal" | "high" | "urgent";
                resolved: boolean;
                sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
                effortScore: number | null;
                resolvedAt: Date | null;
                firstResponseAt: Date | null;
                contextSummary: string | null;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    sendMessage: {
        pathParams: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        summary: "Send a message in a conversation";
        method: "POST";
        body: z.ZodObject<{
            content: z.ZodString;
            role: z.ZodDefault<z.ZodEnum<["user", "assistant"]>>;
            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, "strip", z.ZodTypeAny, {
            role: "user" | "assistant";
            content: string;
            metadata?: Record<string, unknown> | undefined;
        }, {
            content: string;
            metadata?: Record<string, unknown> | undefined;
            role?: "user" | "assistant" | undefined;
        }>;
        path: "/conversations/:id/messages";
        responses: {
            201: z.ZodObject<{
                id: z.ZodString;
                content: z.ZodString;
                role: z.ZodEnum<["user", "assistant", "system"]>;
                agentType: z.ZodNullable<z.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>>;
                tokenCount: z.ZodNumber;
                cost: z.ZodNumber;
                sentiment: z.ZodNullable<z.ZodEnum<["positive", "neutral", "negative", "frustrated", "angry"]>>;
                intent: z.ZodNullable<z.ZodString>;
                metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            } & {
                createdAt: z.ZodDate;
                updatedAt: z.ZodDate;
            }, "strip", z.ZodTypeAny, {
                metadata: Record<string, unknown> | null;
                id: string;
                role: "user" | "assistant" | "system";
                createdAt: Date;
                updatedAt: Date;
                agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | null;
                sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry" | null;
                content: string;
                tokenCount: number;
                cost: number;
                intent: string | null;
            }, {
                metadata: Record<string, unknown> | null;
                id: string;
                role: "user" | "assistant" | "system";
                createdAt: Date;
                updatedAt: Date;
                agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | null;
                sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry" | null;
                content: string;
                tokenCount: number;
                cost: number;
                intent: string | null;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    getMessages: {
        pathParams: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        query: z.ZodObject<{
            page: z.ZodDefault<z.ZodNumber>;
            limit: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            page: number;
            limit: number;
        }, {
            page?: number | undefined;
            limit?: number | undefined;
        }>;
        summary: "Get messages for a conversation";
        method: "GET";
        path: "/conversations/:id/messages";
        responses: {
            200: z.ZodObject<{
                messages: z.ZodArray<z.ZodObject<{
                    id: z.ZodString;
                    content: z.ZodString;
                    role: z.ZodEnum<["user", "assistant", "system"]>;
                    agentType: z.ZodNullable<z.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>>;
                    tokenCount: z.ZodNumber;
                    cost: z.ZodNumber;
                    sentiment: z.ZodNullable<z.ZodEnum<["positive", "neutral", "negative", "frustrated", "angry"]>>;
                    intent: z.ZodNullable<z.ZodString>;
                    metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                } & {
                    createdAt: z.ZodDate;
                    updatedAt: z.ZodDate;
                }, "strip", z.ZodTypeAny, {
                    metadata: Record<string, unknown> | null;
                    id: string;
                    role: "user" | "assistant" | "system";
                    createdAt: Date;
                    updatedAt: Date;
                    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | null;
                    sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry" | null;
                    content: string;
                    tokenCount: number;
                    cost: number;
                    intent: string | null;
                }, {
                    metadata: Record<string, unknown> | null;
                    id: string;
                    role: "user" | "assistant" | "system";
                    createdAt: Date;
                    updatedAt: Date;
                    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | null;
                    sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry" | null;
                    content: string;
                    tokenCount: number;
                    cost: number;
                    intent: string | null;
                }>, "many">;
                pagination: z.ZodObject<{
                    page: z.ZodNumber;
                    limit: z.ZodNumber;
                    total: z.ZodNumber;
                    totalPages: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    page: number;
                    limit: number;
                    total: number;
                    totalPages: number;
                }, {
                    page: number;
                    limit: number;
                    total: number;
                    totalPages: number;
                }>;
            }, "strip", z.ZodTypeAny, {
                messages: {
                    metadata: Record<string, unknown> | null;
                    id: string;
                    role: "user" | "assistant" | "system";
                    createdAt: Date;
                    updatedAt: Date;
                    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | null;
                    sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry" | null;
                    content: string;
                    tokenCount: number;
                    cost: number;
                    intent: string | null;
                }[];
                pagination: {
                    page: number;
                    limit: number;
                    total: number;
                    totalPages: number;
                };
            }, {
                messages: {
                    metadata: Record<string, unknown> | null;
                    id: string;
                    role: "user" | "assistant" | "system";
                    createdAt: Date;
                    updatedAt: Date;
                    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | null;
                    sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry" | null;
                    content: string;
                    tokenCount: number;
                    cost: number;
                    intent: string | null;
                }[];
                pagination: {
                    page: number;
                    limit: number;
                    total: number;
                    totalPages: number;
                };
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
};

declare const agentsContract: {
    getSystemStatus: {
        summary: "Get live agentic system status";
        method: "GET";
        path: "/agents/status";
        responses: {
            200: z.ZodObject<{
                orchestratorLoad: z.ZodNumber;
                resolverActionsPerHour: z.ZodNumber;
                agents: z.ZodArray<z.ZodObject<{
                    type: z.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>;
                    status: z.ZodEnum<["active", "idle"]>;
                }, "strip", z.ZodTypeAny, {
                    type: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                    status: "active" | "idle";
                }, {
                    type: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                    status: "active" | "idle";
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                orchestratorLoad: number;
                resolverActionsPerHour: number;
                agents: {
                    type: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                    status: "active" | "idle";
                }[];
            }, {
                orchestratorLoad: number;
                resolverActionsPerHour: number;
                agents: {
                    type: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                    status: "active" | "idle";
                }[];
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    getAgentStatus: {
        pathParams: z.ZodObject<{
            agentType: z.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>;
        }, "strip", z.ZodTypeAny, {
            agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
        }, {
            agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
        }>;
        summary: "Get status for a specific agent";
        method: "GET";
        path: "/agents/:agentType/status";
        responses: {
            200: z.ZodObject<{
                agentType: z.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>;
                status: z.ZodEnum<["active", "idle", "error"]>;
                currentLoad: z.ZodNumber;
                actionsPerHour: z.ZodNumber;
                averageResponseTime: z.ZodNumber;
                errorRate: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                status: "error" | "active" | "idle";
                agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                currentLoad: number;
                actionsPerHour: number;
                averageResponseTime: number;
                errorRate: number;
            }, {
                status: "error" | "active" | "idle";
                agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                currentLoad: number;
                actionsPerHour: number;
                averageResponseTime: number;
                errorRate: number;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    getAgentMetrics: {
        pathParams: z.ZodObject<{
            agentType: z.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>;
        }, "strip", z.ZodTypeAny, {
            agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
        }, {
            agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
        }>;
        query: z.ZodObject<{
            from: z.ZodDate;
            to: z.ZodDate;
        }, "strip", z.ZodTypeAny, {
            from: Date;
            to: Date;
        }, {
            from: Date;
            to: Date;
        }>;
        summary: "Get performance metrics for an agent";
        method: "GET";
        path: "/agents/:agentType/metrics";
        responses: {
            200: z.ZodObject<{
                agentType: z.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>;
                totalActions: z.ZodNumber;
                successfulActions: z.ZodNumber;
                failedActions: z.ZodNumber;
                averageDuration: z.ZodNumber;
                totalCost: z.ZodNumber;
                totalTokens: z.ZodNumber;
                period: z.ZodObject<{
                    from: z.ZodDate;
                    to: z.ZodDate;
                }, "strip", z.ZodTypeAny, {
                    from: Date;
                    to: Date;
                }, {
                    from: Date;
                    to: Date;
                }>;
            }, "strip", z.ZodTypeAny, {
                agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                totalActions: number;
                successfulActions: number;
                failedActions: number;
                averageDuration: number;
                totalCost: number;
                totalTokens: number;
                period: {
                    from: Date;
                    to: Date;
                };
            }, {
                agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                totalActions: number;
                successfulActions: number;
                failedActions: number;
                averageDuration: number;
                totalCost: number;
                totalTokens: number;
                period: {
                    from: Date;
                    to: Date;
                };
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    getAgentConfig: {
        pathParams: z.ZodObject<{
            agentType: z.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>;
        }, "strip", z.ZodTypeAny, {
            agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
        }, {
            agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
        }>;
        summary: "Get agent configuration";
        method: "GET";
        path: "/agents/:agentType/config";
        responses: {
            200: z.ZodObject<{
                agentType: z.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>;
                enabled: z.ZodBoolean;
                maxConcurrent: z.ZodDefault<z.ZodNumber>;
                timeout: z.ZodDefault<z.ZodNumber>;
                retryAttempts: z.ZodDefault<z.ZodNumber>;
                llmModel: z.ZodDefault<z.ZodString>;
                temperature: z.ZodDefault<z.ZodNumber>;
                systemPrompt: z.ZodOptional<z.ZodString>;
                tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
            }, "strip", z.ZodTypeAny, {
                agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                enabled: boolean;
                maxConcurrent: number;
                timeout: number;
                retryAttempts: number;
                llmModel: string;
                temperature: number;
                tools?: string[] | undefined;
                systemPrompt?: string | undefined;
            }, {
                agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                enabled: boolean;
                tools?: string[] | undefined;
                maxConcurrent?: number | undefined;
                timeout?: number | undefined;
                retryAttempts?: number | undefined;
                llmModel?: string | undefined;
                temperature?: number | undefined;
                systemPrompt?: string | undefined;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    updateAgentConfig: {
        pathParams: z.ZodObject<{
            agentType: z.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>;
        }, "strip", z.ZodTypeAny, {
            agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
        }, {
            agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
        }>;
        summary: "Update agent configuration";
        method: "PATCH";
        body: z.ZodObject<{
            agentType: z.ZodOptional<z.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>>;
            enabled: z.ZodOptional<z.ZodBoolean>;
            maxConcurrent: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
            timeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
            retryAttempts: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
            llmModel: z.ZodOptional<z.ZodDefault<z.ZodString>>;
            temperature: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
            systemPrompt: z.ZodOptional<z.ZodOptional<z.ZodString>>;
            tools: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
        }, "strip", z.ZodTypeAny, {
            agentType?: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | undefined;
            enabled?: boolean | undefined;
            tools?: string[] | undefined;
            maxConcurrent?: number | undefined;
            timeout?: number | undefined;
            retryAttempts?: number | undefined;
            llmModel?: string | undefined;
            temperature?: number | undefined;
            systemPrompt?: string | undefined;
        }, {
            agentType?: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | undefined;
            enabled?: boolean | undefined;
            tools?: string[] | undefined;
            maxConcurrent?: number | undefined;
            timeout?: number | undefined;
            retryAttempts?: number | undefined;
            llmModel?: string | undefined;
            temperature?: number | undefined;
            systemPrompt?: string | undefined;
        }>;
        path: "/agents/:agentType/config";
        responses: {
            200: z.ZodObject<{
                agentType: z.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>;
                enabled: z.ZodBoolean;
                maxConcurrent: z.ZodDefault<z.ZodNumber>;
                timeout: z.ZodDefault<z.ZodNumber>;
                retryAttempts: z.ZodDefault<z.ZodNumber>;
                llmModel: z.ZodDefault<z.ZodString>;
                temperature: z.ZodDefault<z.ZodNumber>;
                systemPrompt: z.ZodOptional<z.ZodString>;
                tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
            }, "strip", z.ZodTypeAny, {
                agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                enabled: boolean;
                maxConcurrent: number;
                timeout: number;
                retryAttempts: number;
                llmModel: string;
                temperature: number;
                tools?: string[] | undefined;
                systemPrompt?: string | undefined;
            }, {
                agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                enabled: boolean;
                tools?: string[] | undefined;
                maxConcurrent?: number | undefined;
                timeout?: number | undefined;
                retryAttempts?: number | undefined;
                llmModel?: string | undefined;
                temperature?: number | undefined;
                systemPrompt?: string | undefined;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    listAgentActions: {
        query: z.ZodObject<{
            page: z.ZodDefault<z.ZodNumber>;
            limit: z.ZodDefault<z.ZodNumber>;
        } & {
            conversationId: z.ZodOptional<z.ZodString>;
            agentType: z.ZodOptional<z.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>>;
            status: z.ZodOptional<z.ZodEnum<["pending", "in_progress", "completed", "failed"]>>;
        }, "strip", z.ZodTypeAny, {
            page: number;
            limit: number;
            status?: "pending" | "in_progress" | "completed" | "failed" | undefined;
            agentType?: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | undefined;
            conversationId?: string | undefined;
        }, {
            status?: "pending" | "in_progress" | "completed" | "failed" | undefined;
            agentType?: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | undefined;
            page?: number | undefined;
            limit?: number | undefined;
            conversationId?: string | undefined;
        }>;
        summary: "List agent actions with filters";
        method: "GET";
        path: "/agents/actions";
        responses: {
            200: z.ZodObject<{
                actions: z.ZodArray<z.ZodObject<{
                    id: z.ZodString;
                    agentType: z.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>;
                    action: z.ZodString;
                    status: z.ZodEnum<["pending", "in_progress", "completed", "failed"]>;
                    input: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                    output: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                    toolName: z.ZodNullable<z.ZodString>;
                    toolParams: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                    toolResult: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                    reasoning: z.ZodNullable<z.ZodString>;
                    tokenCount: z.ZodNumber;
                    cost: z.ZodNumber;
                    duration: z.ZodNullable<z.ZodNumber>;
                    error: z.ZodNullable<z.ZodString>;
                    conversationId: z.ZodString;
                    completedAt: z.ZodNullable<z.ZodDate>;
                } & {
                    createdAt: z.ZodDate;
                    updatedAt: z.ZodDate;
                }, "strip", z.ZodTypeAny, {
                    status: "pending" | "in_progress" | "completed" | "failed";
                    id: string;
                    createdAt: Date;
                    updatedAt: Date;
                    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                    error: string | null;
                    tokenCount: number;
                    cost: number;
                    conversationId: string;
                    action: string;
                    input: Record<string, unknown> | null;
                    output: Record<string, unknown> | null;
                    toolName: string | null;
                    toolParams: Record<string, unknown> | null;
                    toolResult: Record<string, unknown> | null;
                    reasoning: string | null;
                    duration: number | null;
                    completedAt: Date | null;
                }, {
                    status: "pending" | "in_progress" | "completed" | "failed";
                    id: string;
                    createdAt: Date;
                    updatedAt: Date;
                    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                    error: string | null;
                    tokenCount: number;
                    cost: number;
                    conversationId: string;
                    action: string;
                    input: Record<string, unknown> | null;
                    output: Record<string, unknown> | null;
                    toolName: string | null;
                    toolParams: Record<string, unknown> | null;
                    toolResult: Record<string, unknown> | null;
                    reasoning: string | null;
                    duration: number | null;
                    completedAt: Date | null;
                }>, "many">;
                pagination: z.ZodObject<{
                    page: z.ZodNumber;
                    limit: z.ZodNumber;
                    total: z.ZodNumber;
                    totalPages: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    page: number;
                    limit: number;
                    total: number;
                    totalPages: number;
                }, {
                    page: number;
                    limit: number;
                    total: number;
                    totalPages: number;
                }>;
            }, "strip", z.ZodTypeAny, {
                pagination: {
                    page: number;
                    limit: number;
                    total: number;
                    totalPages: number;
                };
                actions: {
                    status: "pending" | "in_progress" | "completed" | "failed";
                    id: string;
                    createdAt: Date;
                    updatedAt: Date;
                    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                    error: string | null;
                    tokenCount: number;
                    cost: number;
                    conversationId: string;
                    action: string;
                    input: Record<string, unknown> | null;
                    output: Record<string, unknown> | null;
                    toolName: string | null;
                    toolParams: Record<string, unknown> | null;
                    toolResult: Record<string, unknown> | null;
                    reasoning: string | null;
                    duration: number | null;
                    completedAt: Date | null;
                }[];
            }, {
                pagination: {
                    page: number;
                    limit: number;
                    total: number;
                    totalPages: number;
                };
                actions: {
                    status: "pending" | "in_progress" | "completed" | "failed";
                    id: string;
                    createdAt: Date;
                    updatedAt: Date;
                    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                    error: string | null;
                    tokenCount: number;
                    cost: number;
                    conversationId: string;
                    action: string;
                    input: Record<string, unknown> | null;
                    output: Record<string, unknown> | null;
                    toolName: string | null;
                    toolParams: Record<string, unknown> | null;
                    toolResult: Record<string, unknown> | null;
                    reasoning: string | null;
                    duration: number | null;
                    completedAt: Date | null;
                }[];
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
};

declare const escalationsContract: {
    createEscalation: {
        summary: "Create a new escalation";
        method: "POST";
        body: z.ZodObject<{
            conversationId: z.ZodString;
            reason: z.ZodString;
            priority: z.ZodDefault<z.ZodEnum<["low", "normal", "high", "urgent"]>>;
            aiSummary: z.ZodString;
            customerContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, "strip", z.ZodTypeAny, {
            priority: "low" | "normal" | "high" | "urgent";
            conversationId: string;
            reason: string;
            aiSummary: string;
            customerContext?: Record<string, unknown> | undefined;
        }, {
            conversationId: string;
            reason: string;
            aiSummary: string;
            priority?: "low" | "normal" | "high" | "urgent" | undefined;
            customerContext?: Record<string, unknown> | undefined;
        }>;
        path: "/escalations";
        responses: {
            201: z.ZodObject<{
                id: z.ZodString;
                reason: z.ZodString;
                priority: z.ZodEnum<["low", "normal", "high", "urgent"]>;
                status: z.ZodEnum<["new", "assigned", "in_progress", "resolved"]>;
                aiSummary: z.ZodString;
                customerContext: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                assignedAt: z.ZodNullable<z.ZodDate>;
                resolvedAt: z.ZodNullable<z.ZodDate>;
                resolution: z.ZodNullable<z.ZodString>;
                conversationId: z.ZodString;
                organizationId: z.ZodString;
                assignedToId: z.ZodNullable<z.ZodString>;
                assignedTo: z.ZodNullable<z.ZodObject<{
                    id: z.ZodString;
                    name: z.ZodString;
                    email: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    email: string;
                    id: string;
                    name: string;
                }, {
                    email: string;
                    id: string;
                    name: string;
                }>>;
            } & {
                createdAt: z.ZodDate;
                updatedAt: z.ZodDate;
            }, "strip", z.ZodTypeAny, {
                status: "resolved" | "in_progress" | "new" | "assigned";
                id: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                priority: "low" | "normal" | "high" | "urgent";
                resolvedAt: Date | null;
                conversationId: string;
                reason: string;
                aiSummary: string;
                customerContext: Record<string, unknown> | null;
                assignedAt: Date | null;
                resolution: string | null;
                assignedToId: string | null;
                assignedTo: {
                    email: string;
                    id: string;
                    name: string;
                } | null;
            }, {
                status: "resolved" | "in_progress" | "new" | "assigned";
                id: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                priority: "low" | "normal" | "high" | "urgent";
                resolvedAt: Date | null;
                conversationId: string;
                reason: string;
                aiSummary: string;
                customerContext: Record<string, unknown> | null;
                assignedAt: Date | null;
                resolution: string | null;
                assignedToId: string | null;
                assignedTo: {
                    email: string;
                    id: string;
                    name: string;
                } | null;
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    getEscalation: {
        pathParams: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        summary: "Get escalation by ID";
        method: "GET";
        path: "/escalations/:id";
        responses: {
            200: z.ZodObject<{
                id: z.ZodString;
                reason: z.ZodString;
                priority: z.ZodEnum<["low", "normal", "high", "urgent"]>;
                status: z.ZodEnum<["new", "assigned", "in_progress", "resolved"]>;
                aiSummary: z.ZodString;
                customerContext: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                assignedAt: z.ZodNullable<z.ZodDate>;
                resolvedAt: z.ZodNullable<z.ZodDate>;
                resolution: z.ZodNullable<z.ZodString>;
                conversationId: z.ZodString;
                organizationId: z.ZodString;
                assignedToId: z.ZodNullable<z.ZodString>;
                assignedTo: z.ZodNullable<z.ZodObject<{
                    id: z.ZodString;
                    name: z.ZodString;
                    email: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    email: string;
                    id: string;
                    name: string;
                }, {
                    email: string;
                    id: string;
                    name: string;
                }>>;
            } & {
                createdAt: z.ZodDate;
                updatedAt: z.ZodDate;
            }, "strip", z.ZodTypeAny, {
                status: "resolved" | "in_progress" | "new" | "assigned";
                id: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                priority: "low" | "normal" | "high" | "urgent";
                resolvedAt: Date | null;
                conversationId: string;
                reason: string;
                aiSummary: string;
                customerContext: Record<string, unknown> | null;
                assignedAt: Date | null;
                resolution: string | null;
                assignedToId: string | null;
                assignedTo: {
                    email: string;
                    id: string;
                    name: string;
                } | null;
            }, {
                status: "resolved" | "in_progress" | "new" | "assigned";
                id: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                priority: "low" | "normal" | "high" | "urgent";
                resolvedAt: Date | null;
                conversationId: string;
                reason: string;
                aiSummary: string;
                customerContext: Record<string, unknown> | null;
                assignedAt: Date | null;
                resolution: string | null;
                assignedToId: string | null;
                assignedTo: {
                    email: string;
                    id: string;
                    name: string;
                } | null;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    listEscalations: {
        query: z.ZodObject<{
            page: z.ZodDefault<z.ZodNumber>;
            limit: z.ZodDefault<z.ZodNumber>;
        } & {
            status: z.ZodOptional<z.ZodEnum<["new", "assigned", "in_progress", "resolved"]>>;
            priority: z.ZodOptional<z.ZodEnum<["low", "normal", "high", "urgent"]>>;
            assignedToId: z.ZodOptional<z.ZodString>;
            fromDate: z.ZodOptional<z.ZodDate>;
            toDate: z.ZodOptional<z.ZodDate>;
        }, "strip", z.ZodTypeAny, {
            page: number;
            limit: number;
            status?: "resolved" | "in_progress" | "new" | "assigned" | undefined;
            priority?: "low" | "normal" | "high" | "urgent" | undefined;
            fromDate?: Date | undefined;
            toDate?: Date | undefined;
            assignedToId?: string | undefined;
        }, {
            status?: "resolved" | "in_progress" | "new" | "assigned" | undefined;
            priority?: "low" | "normal" | "high" | "urgent" | undefined;
            page?: number | undefined;
            limit?: number | undefined;
            fromDate?: Date | undefined;
            toDate?: Date | undefined;
            assignedToId?: string | undefined;
        }>;
        summary: "List escalations with pagination and filters";
        method: "GET";
        path: "/escalations";
        responses: {
            200: z.ZodObject<{
                escalations: z.ZodArray<z.ZodObject<{
                    id: z.ZodString;
                    reason: z.ZodString;
                    priority: z.ZodEnum<["low", "normal", "high", "urgent"]>;
                    status: z.ZodEnum<["new", "assigned", "in_progress", "resolved"]>;
                    aiSummary: z.ZodString;
                    customerContext: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                    assignedAt: z.ZodNullable<z.ZodDate>;
                    resolvedAt: z.ZodNullable<z.ZodDate>;
                    resolution: z.ZodNullable<z.ZodString>;
                    conversationId: z.ZodString;
                    organizationId: z.ZodString;
                    assignedToId: z.ZodNullable<z.ZodString>;
                    assignedTo: z.ZodNullable<z.ZodObject<{
                        id: z.ZodString;
                        name: z.ZodString;
                        email: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        email: string;
                        id: string;
                        name: string;
                    }, {
                        email: string;
                        id: string;
                        name: string;
                    }>>;
                } & {
                    createdAt: z.ZodDate;
                    updatedAt: z.ZodDate;
                }, "strip", z.ZodTypeAny, {
                    status: "resolved" | "in_progress" | "new" | "assigned";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    priority: "low" | "normal" | "high" | "urgent";
                    resolvedAt: Date | null;
                    conversationId: string;
                    reason: string;
                    aiSummary: string;
                    customerContext: Record<string, unknown> | null;
                    assignedAt: Date | null;
                    resolution: string | null;
                    assignedToId: string | null;
                    assignedTo: {
                        email: string;
                        id: string;
                        name: string;
                    } | null;
                }, {
                    status: "resolved" | "in_progress" | "new" | "assigned";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    priority: "low" | "normal" | "high" | "urgent";
                    resolvedAt: Date | null;
                    conversationId: string;
                    reason: string;
                    aiSummary: string;
                    customerContext: Record<string, unknown> | null;
                    assignedAt: Date | null;
                    resolution: string | null;
                    assignedToId: string | null;
                    assignedTo: {
                        email: string;
                        id: string;
                        name: string;
                    } | null;
                }>, "many">;
                pagination: z.ZodObject<{
                    page: z.ZodNumber;
                    limit: z.ZodNumber;
                    total: z.ZodNumber;
                    totalPages: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    page: number;
                    limit: number;
                    total: number;
                    totalPages: number;
                }, {
                    page: number;
                    limit: number;
                    total: number;
                    totalPages: number;
                }>;
            }, "strip", z.ZodTypeAny, {
                pagination: {
                    page: number;
                    limit: number;
                    total: number;
                    totalPages: number;
                };
                escalations: {
                    status: "resolved" | "in_progress" | "new" | "assigned";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    priority: "low" | "normal" | "high" | "urgent";
                    resolvedAt: Date | null;
                    conversationId: string;
                    reason: string;
                    aiSummary: string;
                    customerContext: Record<string, unknown> | null;
                    assignedAt: Date | null;
                    resolution: string | null;
                    assignedToId: string | null;
                    assignedTo: {
                        email: string;
                        id: string;
                        name: string;
                    } | null;
                }[];
            }, {
                pagination: {
                    page: number;
                    limit: number;
                    total: number;
                    totalPages: number;
                };
                escalations: {
                    status: "resolved" | "in_progress" | "new" | "assigned";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    priority: "low" | "normal" | "high" | "urgent";
                    resolvedAt: Date | null;
                    conversationId: string;
                    reason: string;
                    aiSummary: string;
                    customerContext: Record<string, unknown> | null;
                    assignedAt: Date | null;
                    resolution: string | null;
                    assignedToId: string | null;
                    assignedTo: {
                        email: string;
                        id: string;
                        name: string;
                    } | null;
                }[];
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    updateEscalation: {
        pathParams: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        summary: "Update escalation";
        method: "PATCH";
        body: z.ZodObject<{
            status: z.ZodOptional<z.ZodEnum<["new", "assigned", "in_progress", "resolved"]>>;
            priority: z.ZodOptional<z.ZodEnum<["low", "normal", "high", "urgent"]>>;
            assignedToId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
            resolution: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            status?: "resolved" | "in_progress" | "new" | "assigned" | undefined;
            priority?: "low" | "normal" | "high" | "urgent" | undefined;
            resolution?: string | undefined;
            assignedToId?: string | null | undefined;
        }, {
            status?: "resolved" | "in_progress" | "new" | "assigned" | undefined;
            priority?: "low" | "normal" | "high" | "urgent" | undefined;
            resolution?: string | undefined;
            assignedToId?: string | null | undefined;
        }>;
        path: "/escalations/:id";
        responses: {
            200: z.ZodObject<{
                id: z.ZodString;
                reason: z.ZodString;
                priority: z.ZodEnum<["low", "normal", "high", "urgent"]>;
                status: z.ZodEnum<["new", "assigned", "in_progress", "resolved"]>;
                aiSummary: z.ZodString;
                customerContext: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                assignedAt: z.ZodNullable<z.ZodDate>;
                resolvedAt: z.ZodNullable<z.ZodDate>;
                resolution: z.ZodNullable<z.ZodString>;
                conversationId: z.ZodString;
                organizationId: z.ZodString;
                assignedToId: z.ZodNullable<z.ZodString>;
                assignedTo: z.ZodNullable<z.ZodObject<{
                    id: z.ZodString;
                    name: z.ZodString;
                    email: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    email: string;
                    id: string;
                    name: string;
                }, {
                    email: string;
                    id: string;
                    name: string;
                }>>;
            } & {
                createdAt: z.ZodDate;
                updatedAt: z.ZodDate;
            }, "strip", z.ZodTypeAny, {
                status: "resolved" | "in_progress" | "new" | "assigned";
                id: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                priority: "low" | "normal" | "high" | "urgent";
                resolvedAt: Date | null;
                conversationId: string;
                reason: string;
                aiSummary: string;
                customerContext: Record<string, unknown> | null;
                assignedAt: Date | null;
                resolution: string | null;
                assignedToId: string | null;
                assignedTo: {
                    email: string;
                    id: string;
                    name: string;
                } | null;
            }, {
                status: "resolved" | "in_progress" | "new" | "assigned";
                id: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                priority: "low" | "normal" | "high" | "urgent";
                resolvedAt: Date | null;
                conversationId: string;
                reason: string;
                aiSummary: string;
                customerContext: Record<string, unknown> | null;
                assignedAt: Date | null;
                resolution: string | null;
                assignedToId: string | null;
                assignedTo: {
                    email: string;
                    id: string;
                    name: string;
                } | null;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    assignEscalation: {
        pathParams: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        summary: "Assign escalation to a user";
        method: "POST";
        body: z.ZodObject<{
            userId: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            userId: string;
        }, {
            userId: string;
        }>;
        path: "/escalations/:id/assign";
        responses: {
            200: z.ZodObject<{
                id: z.ZodString;
                reason: z.ZodString;
                priority: z.ZodEnum<["low", "normal", "high", "urgent"]>;
                status: z.ZodEnum<["new", "assigned", "in_progress", "resolved"]>;
                aiSummary: z.ZodString;
                customerContext: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                assignedAt: z.ZodNullable<z.ZodDate>;
                resolvedAt: z.ZodNullable<z.ZodDate>;
                resolution: z.ZodNullable<z.ZodString>;
                conversationId: z.ZodString;
                organizationId: z.ZodString;
                assignedToId: z.ZodNullable<z.ZodString>;
                assignedTo: z.ZodNullable<z.ZodObject<{
                    id: z.ZodString;
                    name: z.ZodString;
                    email: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    email: string;
                    id: string;
                    name: string;
                }, {
                    email: string;
                    id: string;
                    name: string;
                }>>;
            } & {
                createdAt: z.ZodDate;
                updatedAt: z.ZodDate;
            }, "strip", z.ZodTypeAny, {
                status: "resolved" | "in_progress" | "new" | "assigned";
                id: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                priority: "low" | "normal" | "high" | "urgent";
                resolvedAt: Date | null;
                conversationId: string;
                reason: string;
                aiSummary: string;
                customerContext: Record<string, unknown> | null;
                assignedAt: Date | null;
                resolution: string | null;
                assignedToId: string | null;
                assignedTo: {
                    email: string;
                    id: string;
                    name: string;
                } | null;
            }, {
                status: "resolved" | "in_progress" | "new" | "assigned";
                id: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                priority: "low" | "normal" | "high" | "urgent";
                resolvedAt: Date | null;
                conversationId: string;
                reason: string;
                aiSummary: string;
                customerContext: Record<string, unknown> | null;
                assignedAt: Date | null;
                resolution: string | null;
                assignedToId: string | null;
                assignedTo: {
                    email: string;
                    id: string;
                    name: string;
                } | null;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    resolveEscalation: {
        pathParams: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        summary: "Mark escalation as resolved";
        method: "POST";
        body: z.ZodObject<{
            resolution: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            resolution: string;
        }, {
            resolution: string;
        }>;
        path: "/escalations/:id/resolve";
        responses: {
            200: z.ZodObject<{
                id: z.ZodString;
                reason: z.ZodString;
                priority: z.ZodEnum<["low", "normal", "high", "urgent"]>;
                status: z.ZodEnum<["new", "assigned", "in_progress", "resolved"]>;
                aiSummary: z.ZodString;
                customerContext: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                assignedAt: z.ZodNullable<z.ZodDate>;
                resolvedAt: z.ZodNullable<z.ZodDate>;
                resolution: z.ZodNullable<z.ZodString>;
                conversationId: z.ZodString;
                organizationId: z.ZodString;
                assignedToId: z.ZodNullable<z.ZodString>;
                assignedTo: z.ZodNullable<z.ZodObject<{
                    id: z.ZodString;
                    name: z.ZodString;
                    email: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    email: string;
                    id: string;
                    name: string;
                }, {
                    email: string;
                    id: string;
                    name: string;
                }>>;
            } & {
                createdAt: z.ZodDate;
                updatedAt: z.ZodDate;
            }, "strip", z.ZodTypeAny, {
                status: "resolved" | "in_progress" | "new" | "assigned";
                id: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                priority: "low" | "normal" | "high" | "urgent";
                resolvedAt: Date | null;
                conversationId: string;
                reason: string;
                aiSummary: string;
                customerContext: Record<string, unknown> | null;
                assignedAt: Date | null;
                resolution: string | null;
                assignedToId: string | null;
                assignedTo: {
                    email: string;
                    id: string;
                    name: string;
                } | null;
            }, {
                status: "resolved" | "in_progress" | "new" | "assigned";
                id: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                priority: "low" | "normal" | "high" | "urgent";
                resolvedAt: Date | null;
                conversationId: string;
                reason: string;
                aiSummary: string;
                customerContext: Record<string, unknown> | null;
                assignedAt: Date | null;
                resolution: string | null;
                assignedToId: string | null;
                assignedTo: {
                    email: string;
                    id: string;
                    name: string;
                } | null;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
};

declare const analyticsContract: {
    getDashboardMetrics: {
        query: z.ZodObject<{
            period: z.ZodDefault<z.ZodEnum<["7d", "30d", "90d"]>>;
        }, "strip", z.ZodTypeAny, {
            period: "7d" | "30d" | "90d";
        }, {
            period?: "7d" | "30d" | "90d" | undefined;
        }>;
        summary: "Get dashboard metrics (FCR, CES, EVI, ROI)";
        method: "GET";
        path: "/analytics/dashboard";
        responses: {
            200: z.ZodObject<{
                firstContactResolution: z.ZodObject<{
                    value: z.ZodNumber;
                    change: z.ZodNumber;
                    changeType: z.ZodEnum<["increase", "decrease"]>;
                }, "strip", z.ZodTypeAny, {
                    value: number;
                    change: number;
                    changeType: "increase" | "decrease";
                }, {
                    value: number;
                    change: number;
                    changeType: "increase" | "decrease";
                }>;
                customerEffortScore: z.ZodObject<{
                    value: z.ZodNumber;
                    change: z.ZodNumber;
                    changeType: z.ZodEnum<["increase", "decrease"]>;
                }, "strip", z.ZodTypeAny, {
                    value: number;
                    change: number;
                    changeType: "increase" | "decrease";
                }, {
                    value: number;
                    change: number;
                    changeType: "increase" | "decrease";
                }>;
                emotionalValueIndex: z.ZodObject<{
                    value: z.ZodNumber;
                    change: z.ZodNumber;
                    changeType: z.ZodEnum<["increase", "decrease"]>;
                }, "strip", z.ZodTypeAny, {
                    value: number;
                    change: number;
                    changeType: "increase" | "decrease";
                }, {
                    value: number;
                    change: number;
                    changeType: "increase" | "decrease";
                }>;
                supportROI: z.ZodObject<{
                    value: z.ZodNumber;
                    retainedRevenue: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    value: number;
                    retainedRevenue: number;
                }, {
                    value: number;
                    retainedRevenue: number;
                }>;
            }, "strip", z.ZodTypeAny, {
                firstContactResolution: {
                    value: number;
                    change: number;
                    changeType: "increase" | "decrease";
                };
                customerEffortScore: {
                    value: number;
                    change: number;
                    changeType: "increase" | "decrease";
                };
                emotionalValueIndex: {
                    value: number;
                    change: number;
                    changeType: "increase" | "decrease";
                };
                supportROI: {
                    value: number;
                    retainedRevenue: number;
                };
            }, {
                firstContactResolution: {
                    value: number;
                    change: number;
                    changeType: "increase" | "decrease";
                };
                customerEffortScore: {
                    value: number;
                    change: number;
                    changeType: "increase" | "decrease";
                };
                emotionalValueIndex: {
                    value: number;
                    change: number;
                    changeType: "increase" | "decrease";
                };
                supportROI: {
                    value: number;
                    retainedRevenue: number;
                };
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    getSentimentOverTime: {
        query: z.ZodObject<{
            from: z.ZodDate;
            to: z.ZodDate;
            granularity: z.ZodDefault<z.ZodEnum<["hour", "day", "week", "month"]>>;
        }, "strip", z.ZodTypeAny, {
            from: Date;
            to: Date;
            granularity: "hour" | "day" | "week" | "month";
        }, {
            from: Date;
            to: Date;
            granularity?: "hour" | "day" | "week" | "month" | undefined;
        }>;
        summary: "Get sentiment (EVI) over time";
        method: "GET";
        path: "/analytics/sentiment";
        responses: {
            200: z.ZodObject<{
                dataPoints: z.ZodArray<z.ZodObject<{
                    date: z.ZodDate;
                    evi: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    date: Date;
                    evi: number;
                }, {
                    date: Date;
                    evi: number;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                dataPoints: {
                    date: Date;
                    evi: number;
                }[];
            }, {
                dataPoints: {
                    date: Date;
                    evi: number;
                }[];
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    getFrustrationDrivers: {
        query: z.ZodObject<{
            limit: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            limit: number;
        }, {
            limit?: number | undefined;
        }>;
        summary: "Get top frustration drivers";
        method: "GET";
        path: "/analytics/frustration-drivers";
        responses: {
            200: z.ZodObject<{
                drivers: z.ZodArray<z.ZodObject<{
                    topic: z.ZodString;
                    mentions: z.ZodNumber;
                    percentage: z.ZodNumber;
                    severity: z.ZodEnum<["low", "medium", "high"]>;
                }, "strip", z.ZodTypeAny, {
                    topic: string;
                    mentions: number;
                    percentage: number;
                    severity: "low" | "high" | "medium";
                }, {
                    topic: string;
                    mentions: number;
                    percentage: number;
                    severity: "low" | "high" | "medium";
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                drivers: {
                    topic: string;
                    mentions: number;
                    percentage: number;
                    severity: "low" | "high" | "medium";
                }[];
            }, {
                drivers: {
                    topic: string;
                    mentions: number;
                    percentage: number;
                    severity: "low" | "high" | "medium";
                }[];
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    getEmergingIssues: {
        query: z.ZodObject<{
            limit: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            limit: number;
        }, {
            limit?: number | undefined;
        }>;
        summary: "Get emerging issues trending upward";
        method: "GET";
        path: "/analytics/emerging-issues";
        responses: {
            200: z.ZodObject<{
                issues: z.ZodArray<z.ZodObject<{
                    topic: z.ZodString;
                    mentions: z.ZodNumber;
                    growthRate: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    topic: string;
                    mentions: number;
                    growthRate: number;
                }, {
                    topic: string;
                    mentions: number;
                    growthRate: number;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                issues: {
                    topic: string;
                    mentions: number;
                    growthRate: number;
                }[];
            }, {
                issues: {
                    topic: string;
                    mentions: number;
                    growthRate: number;
                }[];
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    getConversationMetrics: {
        pathParams: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        summary: "Get detailed metrics for a specific conversation";
        method: "GET";
        path: "/analytics/conversations/:id/metrics";
        responses: {
            200: z.ZodObject<{
                id: z.ZodString;
                conversationId: z.ZodString;
                firstContactResolution: z.ZodBoolean;
                effortScore: z.ZodNullable<z.ZodNumber>;
                emotionalValueIndex: z.ZodNullable<z.ZodNumber>;
                totalMessages: z.ZodNumber;
                totalTokens: z.ZodNumber;
                totalCost: z.ZodNumber;
                agentsInvolved: z.ZodArray<z.ZodString, "many">;
                toolsUsed: z.ZodArray<z.ZodString, "many">;
                durationSeconds: z.ZodNullable<z.ZodNumber>;
                resolutionTimeSeconds: z.ZodNullable<z.ZodNumber>;
                calculatedAt: z.ZodDate;
            }, "strip", z.ZodTypeAny, {
                id: string;
                effortScore: number | null;
                totalCost: number;
                totalTokens: number;
                conversationId: string;
                firstContactResolution: boolean;
                emotionalValueIndex: number | null;
                totalMessages: number;
                agentsInvolved: string[];
                toolsUsed: string[];
                durationSeconds: number | null;
                resolutionTimeSeconds: number | null;
                calculatedAt: Date;
            }, {
                id: string;
                effortScore: number | null;
                totalCost: number;
                totalTokens: number;
                conversationId: string;
                firstContactResolution: boolean;
                emotionalValueIndex: number | null;
                totalMessages: number;
                agentsInvolved: string[];
                toolsUsed: string[];
                durationSeconds: number | null;
                resolutionTimeSeconds: number | null;
                calculatedAt: Date;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    getFinOpsMetrics: {
        query: z.ZodObject<{
            period: z.ZodDefault<z.ZodEnum<["7d", "30d", "90d"]>>;
        }, "strip", z.ZodTypeAny, {
            period: "7d" | "30d" | "90d";
        }, {
            period?: "7d" | "30d" | "90d" | undefined;
        }>;
        summary: "Get FinOps cost tracking metrics";
        method: "GET";
        path: "/analytics/finops";
        responses: {
            200: z.ZodObject<{
                totalSpend: z.ZodObject<{
                    value: z.ZodNumber;
                    period: z.ZodString;
                    change: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    value: number;
                    period: string;
                    change: number;
                }, {
                    value: number;
                    period: string;
                    change: number;
                }>;
                resolvedConversations: z.ZodObject<{
                    value: z.ZodNumber;
                    change: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    value: number;
                    change: number;
                }, {
                    value: number;
                    change: number;
                }>;
                avgCostPerResolution: z.ZodObject<{
                    value: z.ZodNumber;
                    change: z.ZodNumber;
                    changeType: z.ZodEnum<["increase", "decrease"]>;
                }, "strip", z.ZodTypeAny, {
                    value: number;
                    change: number;
                    changeType: "increase" | "decrease";
                }, {
                    value: number;
                    change: number;
                    changeType: "increase" | "decrease";
                }>;
                dataEgressFees: z.ZodObject<{
                    value: z.ZodNumber;
                    poweredBy: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    value: number;
                    poweredBy: string;
                }, {
                    value: number;
                    poweredBy: string;
                }>;
                spendOverTime: z.ZodArray<z.ZodObject<{
                    date: z.ZodDate;
                    spend: z.ZodNumber;
                    limit: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    date: Date;
                    limit: number;
                    spend: number;
                }, {
                    date: Date;
                    limit: number;
                    spend: number;
                }>, "many">;
                usageBreakdown: z.ZodArray<z.ZodObject<{
                    conversationId: z.ZodString;
                    date: z.ZodDate;
                    agentsInvolved: z.ZodArray<z.ZodString, "many">;
                    tokens: z.ZodNumber;
                    totalCost: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    date: Date;
                    totalCost: number;
                    conversationId: string;
                    agentsInvolved: string[];
                    tokens: number;
                }, {
                    date: Date;
                    totalCost: number;
                    conversationId: string;
                    agentsInvolved: string[];
                    tokens: number;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                totalSpend: {
                    value: number;
                    period: string;
                    change: number;
                };
                resolvedConversations: {
                    value: number;
                    change: number;
                };
                avgCostPerResolution: {
                    value: number;
                    change: number;
                    changeType: "increase" | "decrease";
                };
                dataEgressFees: {
                    value: number;
                    poweredBy: string;
                };
                spendOverTime: {
                    date: Date;
                    limit: number;
                    spend: number;
                }[];
                usageBreakdown: {
                    date: Date;
                    totalCost: number;
                    conversationId: string;
                    agentsInvolved: string[];
                    tokens: number;
                }[];
            }, {
                totalSpend: {
                    value: number;
                    period: string;
                    change: number;
                };
                resolvedConversations: {
                    value: number;
                    change: number;
                };
                avgCostPerResolution: {
                    value: number;
                    change: number;
                    changeType: "increase" | "decrease";
                };
                dataEgressFees: {
                    value: number;
                    poweredBy: string;
                };
                spendOverTime: {
                    date: Date;
                    limit: number;
                    spend: number;
                }[];
                usageBreakdown: {
                    date: Date;
                    totalCost: number;
                    conversationId: string;
                    agentsInvolved: string[];
                    tokens: number;
                }[];
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
};

declare const auditContract: {
    listAuditLogs: {
        query: z.ZodObject<{
            page: z.ZodDefault<z.ZodNumber>;
            limit: z.ZodDefault<z.ZodNumber>;
        } & {
            action: z.ZodOptional<z.ZodString>;
            actorType: z.ZodOptional<z.ZodEnum<["user", "agent", "system"]>>;
            actorId: z.ZodOptional<z.ZodString>;
            targetType: z.ZodOptional<z.ZodString>;
            targetId: z.ZodOptional<z.ZodString>;
            fromDate: z.ZodOptional<z.ZodDate>;
            toDate: z.ZodOptional<z.ZodDate>;
        }, "strip", z.ZodTypeAny, {
            page: number;
            limit: number;
            fromDate?: Date | undefined;
            toDate?: Date | undefined;
            action?: string | undefined;
            actorType?: "user" | "agent" | "system" | undefined;
            actorId?: string | undefined;
            targetType?: string | undefined;
            targetId?: string | undefined;
        }, {
            page?: number | undefined;
            limit?: number | undefined;
            fromDate?: Date | undefined;
            toDate?: Date | undefined;
            action?: string | undefined;
            actorType?: "user" | "agent" | "system" | undefined;
            actorId?: string | undefined;
            targetType?: string | undefined;
            targetId?: string | undefined;
        }>;
        summary: "List audit logs with XAI trail";
        method: "GET";
        path: "/audit/logs";
        responses: {
            200: z.ZodObject<{
                logs: z.ZodArray<z.ZodObject<{
                    id: z.ZodString;
                    action: z.ZodString;
                    actorType: z.ZodEnum<["user", "agent", "system"]>;
                    actorId: z.ZodNullable<z.ZodString>;
                    targetType: z.ZodNullable<z.ZodString>;
                    targetId: z.ZodNullable<z.ZodString>;
                    details: z.ZodRecord<z.ZodString, z.ZodUnknown>;
                    decision: z.ZodNullable<z.ZodString>;
                    reasoning: z.ZodNullable<z.ZodString>;
                    rbacCheck: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                    ipAddress: z.ZodNullable<z.ZodString>;
                    userAgent: z.ZodNullable<z.ZodString>;
                    timestamp: z.ZodDate;
                    organizationId: z.ZodString;
                    userId: z.ZodNullable<z.ZodString>;
                    agentActionId: z.ZodNullable<z.ZodString>;
                }, "strip", z.ZodTypeAny, {
                    id: string;
                    organizationId: string;
                    details: Record<string, unknown>;
                    userId: string | null;
                    action: string;
                    reasoning: string | null;
                    actorType: "user" | "agent" | "system";
                    actorId: string | null;
                    targetType: string | null;
                    targetId: string | null;
                    decision: string | null;
                    rbacCheck: Record<string, unknown> | null;
                    ipAddress: string | null;
                    userAgent: string | null;
                    timestamp: Date;
                    agentActionId: string | null;
                }, {
                    id: string;
                    organizationId: string;
                    details: Record<string, unknown>;
                    userId: string | null;
                    action: string;
                    reasoning: string | null;
                    actorType: "user" | "agent" | "system";
                    actorId: string | null;
                    targetType: string | null;
                    targetId: string | null;
                    decision: string | null;
                    rbacCheck: Record<string, unknown> | null;
                    ipAddress: string | null;
                    userAgent: string | null;
                    timestamp: Date;
                    agentActionId: string | null;
                }>, "many">;
                pagination: z.ZodObject<{
                    page: z.ZodNumber;
                    limit: z.ZodNumber;
                    total: z.ZodNumber;
                    totalPages: z.ZodNumber;
                }, "strip", z.ZodTypeAny, {
                    page: number;
                    limit: number;
                    total: number;
                    totalPages: number;
                }, {
                    page: number;
                    limit: number;
                    total: number;
                    totalPages: number;
                }>;
            }, "strip", z.ZodTypeAny, {
                pagination: {
                    page: number;
                    limit: number;
                    total: number;
                    totalPages: number;
                };
                logs: {
                    id: string;
                    organizationId: string;
                    details: Record<string, unknown>;
                    userId: string | null;
                    action: string;
                    reasoning: string | null;
                    actorType: "user" | "agent" | "system";
                    actorId: string | null;
                    targetType: string | null;
                    targetId: string | null;
                    decision: string | null;
                    rbacCheck: Record<string, unknown> | null;
                    ipAddress: string | null;
                    userAgent: string | null;
                    timestamp: Date;
                    agentActionId: string | null;
                }[];
            }, {
                pagination: {
                    page: number;
                    limit: number;
                    total: number;
                    totalPages: number;
                };
                logs: {
                    id: string;
                    organizationId: string;
                    details: Record<string, unknown>;
                    userId: string | null;
                    action: string;
                    reasoning: string | null;
                    actorType: "user" | "agent" | "system";
                    actorId: string | null;
                    targetType: string | null;
                    targetId: string | null;
                    decision: string | null;
                    rbacCheck: Record<string, unknown> | null;
                    ipAddress: string | null;
                    userAgent: string | null;
                    timestamp: Date;
                    agentActionId: string | null;
                }[];
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    getAuditLog: {
        pathParams: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        summary: "Get detailed audit log entry";
        method: "GET";
        path: "/audit/logs/:id";
        responses: {
            200: z.ZodObject<{
                id: z.ZodString;
                action: z.ZodString;
                actorType: z.ZodEnum<["user", "agent", "system"]>;
                actorId: z.ZodNullable<z.ZodString>;
                targetType: z.ZodNullable<z.ZodString>;
                targetId: z.ZodNullable<z.ZodString>;
                details: z.ZodRecord<z.ZodString, z.ZodUnknown>;
                decision: z.ZodNullable<z.ZodString>;
                reasoning: z.ZodNullable<z.ZodString>;
                rbacCheck: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                ipAddress: z.ZodNullable<z.ZodString>;
                userAgent: z.ZodNullable<z.ZodString>;
                timestamp: z.ZodDate;
                organizationId: z.ZodString;
                userId: z.ZodNullable<z.ZodString>;
                agentActionId: z.ZodNullable<z.ZodString>;
            }, "strip", z.ZodTypeAny, {
                id: string;
                organizationId: string;
                details: Record<string, unknown>;
                userId: string | null;
                action: string;
                reasoning: string | null;
                actorType: "user" | "agent" | "system";
                actorId: string | null;
                targetType: string | null;
                targetId: string | null;
                decision: string | null;
                rbacCheck: Record<string, unknown> | null;
                ipAddress: string | null;
                userAgent: string | null;
                timestamp: Date;
                agentActionId: string | null;
            }, {
                id: string;
                organizationId: string;
                details: Record<string, unknown>;
                userId: string | null;
                action: string;
                reasoning: string | null;
                actorType: "user" | "agent" | "system";
                actorId: string | null;
                targetType: string | null;
                targetId: string | null;
                decision: string | null;
                rbacCheck: Record<string, unknown> | null;
                ipAddress: string | null;
                userAgent: string | null;
                timestamp: Date;
                agentActionId: string | null;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    checkPermission: {
        summary: "Check RBAC permission for current user";
        method: "POST";
        body: z.ZodObject<{
            resource: z.ZodString;
            action: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            action: string;
            resource: string;
        }, {
            action: string;
            resource: string;
        }>;
        path: "/audit/rbac/check";
        responses: {
            200: z.ZodObject<{
                resource: z.ZodString;
                action: z.ZodString;
                allowed: z.ZodBoolean;
                reason: z.ZodOptional<z.ZodString>;
            }, "strip", z.ZodTypeAny, {
                action: string;
                resource: string;
                allowed: boolean;
                reason?: string | undefined;
            }, {
                action: string;
                resource: string;
                allowed: boolean;
                reason?: string | undefined;
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    exportAuditLog: {
        summary: "Export audit logs to JSON or CSV";
        method: "POST";
        body: z.ZodObject<{
            format: z.ZodEnum<["json", "csv"]>;
            filters: z.ZodOptional<z.ZodObject<{
                action: z.ZodOptional<z.ZodString>;
                actorType: z.ZodOptional<z.ZodEnum<["user", "agent", "system"]>>;
                actorId: z.ZodOptional<z.ZodString>;
                targetType: z.ZodOptional<z.ZodString>;
                targetId: z.ZodOptional<z.ZodString>;
                fromDate: z.ZodOptional<z.ZodDate>;
                toDate: z.ZodOptional<z.ZodDate>;
            }, "strip", z.ZodTypeAny, {
                fromDate?: Date | undefined;
                toDate?: Date | undefined;
                action?: string | undefined;
                actorType?: "user" | "agent" | "system" | undefined;
                actorId?: string | undefined;
                targetType?: string | undefined;
                targetId?: string | undefined;
            }, {
                fromDate?: Date | undefined;
                toDate?: Date | undefined;
                action?: string | undefined;
                actorType?: "user" | "agent" | "system" | undefined;
                actorId?: string | undefined;
                targetType?: string | undefined;
                targetId?: string | undefined;
            }>>;
        }, "strip", z.ZodTypeAny, {
            format: "json" | "csv";
            filters?: {
                fromDate?: Date | undefined;
                toDate?: Date | undefined;
                action?: string | undefined;
                actorType?: "user" | "agent" | "system" | undefined;
                actorId?: string | undefined;
                targetType?: string | undefined;
                targetId?: string | undefined;
            } | undefined;
        }, {
            format: "json" | "csv";
            filters?: {
                fromDate?: Date | undefined;
                toDate?: Date | undefined;
                action?: string | undefined;
                actorType?: "user" | "agent" | "system" | undefined;
                actorId?: string | undefined;
                targetType?: string | undefined;
                targetId?: string | undefined;
            } | undefined;
        }>;
        path: "/audit/logs/export";
        responses: {
            200: z.ZodObject<{
                downloadUrl: z.ZodString;
                expiresAt: z.ZodDate;
            }, "strip", z.ZodTypeAny, {
                expiresAt: Date;
                downloadUrl: string;
            }, {
                expiresAt: Date;
                downloadUrl: string;
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
};

declare const integrationsContract: {
    listIntegrations: {
        summary: "List all integrations";
        method: "GET";
        path: "/integrations";
        responses: {
            200: z.ZodObject<{
                integrations: z.ZodArray<z.ZodObject<{
                    id: z.ZodString;
                    type: z.ZodEnum<["salesforce", "slack", "zendesk"]>;
                    name: z.ZodString;
                    status: z.ZodEnum<["connected", "disconnected", "error"]>;
                    lastSyncAt: z.ZodNullable<z.ZodDate>;
                    syncStatus: z.ZodNullable<z.ZodEnum<["success", "failed", "in_progress"]>>;
                    syncError: z.ZodNullable<z.ZodString>;
                    organizationId: z.ZodString;
                } & {
                    createdAt: z.ZodDate;
                    updatedAt: z.ZodDate;
                }, "strip", z.ZodTypeAny, {
                    type: "slack" | "salesforce" | "zendesk";
                    status: "error" | "connected" | "disconnected";
                    id: string;
                    name: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    lastSyncAt: Date | null;
                    syncStatus: "success" | "in_progress" | "failed" | null;
                    syncError: string | null;
                }, {
                    type: "slack" | "salesforce" | "zendesk";
                    status: "error" | "connected" | "disconnected";
                    id: string;
                    name: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    lastSyncAt: Date | null;
                    syncStatus: "success" | "in_progress" | "failed" | null;
                    syncError: string | null;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                integrations: {
                    type: "slack" | "salesforce" | "zendesk";
                    status: "error" | "connected" | "disconnected";
                    id: string;
                    name: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    lastSyncAt: Date | null;
                    syncStatus: "success" | "in_progress" | "failed" | null;
                    syncError: string | null;
                }[];
            }, {
                integrations: {
                    type: "slack" | "salesforce" | "zendesk";
                    status: "error" | "connected" | "disconnected";
                    id: string;
                    name: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    lastSyncAt: Date | null;
                    syncStatus: "success" | "in_progress" | "failed" | null;
                    syncError: string | null;
                }[];
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    getIntegration: {
        pathParams: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        summary: "Get integration by ID";
        method: "GET";
        path: "/integrations/:id";
        responses: {
            200: z.ZodObject<{
                id: z.ZodString;
                type: z.ZodEnum<["salesforce", "slack", "zendesk"]>;
                name: z.ZodString;
                status: z.ZodEnum<["connected", "disconnected", "error"]>;
                lastSyncAt: z.ZodNullable<z.ZodDate>;
                syncStatus: z.ZodNullable<z.ZodEnum<["success", "failed", "in_progress"]>>;
                syncError: z.ZodNullable<z.ZodString>;
                organizationId: z.ZodString;
            } & {
                createdAt: z.ZodDate;
                updatedAt: z.ZodDate;
            }, "strip", z.ZodTypeAny, {
                type: "slack" | "salesforce" | "zendesk";
                status: "error" | "connected" | "disconnected";
                id: string;
                name: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                lastSyncAt: Date | null;
                syncStatus: "success" | "in_progress" | "failed" | null;
                syncError: string | null;
            }, {
                type: "slack" | "salesforce" | "zendesk";
                status: "error" | "connected" | "disconnected";
                id: string;
                name: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                lastSyncAt: Date | null;
                syncStatus: "success" | "in_progress" | "failed" | null;
                syncError: string | null;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    createIntegration: {
        summary: "Create a new integration";
        method: "POST";
        body: z.ZodObject<{
            type: z.ZodEnum<["salesforce", "slack", "zendesk"]>;
            name: z.ZodString;
            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
            credentials: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        }, "strip", z.ZodTypeAny, {
            type: "slack" | "salesforce" | "zendesk";
            name: string;
            config: Record<string, unknown>;
            credentials: Record<string, unknown>;
        }, {
            type: "slack" | "salesforce" | "zendesk";
            name: string;
            config: Record<string, unknown>;
            credentials: Record<string, unknown>;
        }>;
        path: "/integrations";
        responses: {
            201: z.ZodObject<{
                id: z.ZodString;
                type: z.ZodEnum<["salesforce", "slack", "zendesk"]>;
                name: z.ZodString;
                status: z.ZodEnum<["connected", "disconnected", "error"]>;
                lastSyncAt: z.ZodNullable<z.ZodDate>;
                syncStatus: z.ZodNullable<z.ZodEnum<["success", "failed", "in_progress"]>>;
                syncError: z.ZodNullable<z.ZodString>;
                organizationId: z.ZodString;
            } & {
                createdAt: z.ZodDate;
                updatedAt: z.ZodDate;
            }, "strip", z.ZodTypeAny, {
                type: "slack" | "salesforce" | "zendesk";
                status: "error" | "connected" | "disconnected";
                id: string;
                name: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                lastSyncAt: Date | null;
                syncStatus: "success" | "in_progress" | "failed" | null;
                syncError: string | null;
            }, {
                type: "slack" | "salesforce" | "zendesk";
                status: "error" | "connected" | "disconnected";
                id: string;
                name: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                lastSyncAt: Date | null;
                syncStatus: "success" | "in_progress" | "failed" | null;
                syncError: string | null;
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    updateIntegration: {
        pathParams: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        summary: "Update integration";
        method: "PATCH";
        body: z.ZodObject<{
            name: z.ZodOptional<z.ZodString>;
            config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            credentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, "strip", z.ZodTypeAny, {
            name?: string | undefined;
            config?: Record<string, unknown> | undefined;
            credentials?: Record<string, unknown> | undefined;
        }, {
            name?: string | undefined;
            config?: Record<string, unknown> | undefined;
            credentials?: Record<string, unknown> | undefined;
        }>;
        path: "/integrations/:id";
        responses: {
            200: z.ZodObject<{
                id: z.ZodString;
                type: z.ZodEnum<["salesforce", "slack", "zendesk"]>;
                name: z.ZodString;
                status: z.ZodEnum<["connected", "disconnected", "error"]>;
                lastSyncAt: z.ZodNullable<z.ZodDate>;
                syncStatus: z.ZodNullable<z.ZodEnum<["success", "failed", "in_progress"]>>;
                syncError: z.ZodNullable<z.ZodString>;
                organizationId: z.ZodString;
            } & {
                createdAt: z.ZodDate;
                updatedAt: z.ZodDate;
            }, "strip", z.ZodTypeAny, {
                type: "slack" | "salesforce" | "zendesk";
                status: "error" | "connected" | "disconnected";
                id: string;
                name: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                lastSyncAt: Date | null;
                syncStatus: "success" | "in_progress" | "failed" | null;
                syncError: string | null;
            }, {
                type: "slack" | "salesforce" | "zendesk";
                status: "error" | "connected" | "disconnected";
                id: string;
                name: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                lastSyncAt: Date | null;
                syncStatus: "success" | "in_progress" | "failed" | null;
                syncError: string | null;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    deleteIntegration: {
        pathParams: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        summary: "Delete integration";
        method: "DELETE";
        body: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
        path: "/integrations/:id";
        responses: {
            200: z.ZodObject<{
                message: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                message: string;
            }, {
                message: string;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    syncIntegration: {
        pathParams: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        summary: "Trigger manual sync for integration";
        method: "POST";
        body: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
        path: "/integrations/:id/sync";
        responses: {
            200: z.ZodObject<{
                id: z.ZodString;
                type: z.ZodEnum<["salesforce", "slack", "zendesk"]>;
                name: z.ZodString;
                status: z.ZodEnum<["connected", "disconnected", "error"]>;
                lastSyncAt: z.ZodNullable<z.ZodDate>;
                syncStatus: z.ZodNullable<z.ZodEnum<["success", "failed", "in_progress"]>>;
                syncError: z.ZodNullable<z.ZodString>;
                organizationId: z.ZodString;
            } & {
                createdAt: z.ZodDate;
                updatedAt: z.ZodDate;
            }, "strip", z.ZodTypeAny, {
                type: "slack" | "salesforce" | "zendesk";
                status: "error" | "connected" | "disconnected";
                id: string;
                name: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                lastSyncAt: Date | null;
                syncStatus: "success" | "in_progress" | "failed" | null;
                syncError: string | null;
            }, {
                type: "slack" | "salesforce" | "zendesk";
                status: "error" | "connected" | "disconnected";
                id: string;
                name: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                lastSyncAt: Date | null;
                syncStatus: "success" | "in_progress" | "failed" | null;
                syncError: string | null;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    listWebhooks: {
        summary: "List all webhooks";
        method: "GET";
        path: "/webhooks";
        responses: {
            200: z.ZodObject<{
                webhooks: z.ZodArray<z.ZodObject<{
                    id: z.ZodString;
                    url: z.ZodString;
                    events: z.ZodArray<z.ZodString, "many">;
                    status: z.ZodEnum<["active", "paused", "failed"]>;
                    lastTriggered: z.ZodNullable<z.ZodDate>;
                    failureCount: z.ZodNumber;
                    organizationId: z.ZodString;
                } & {
                    createdAt: z.ZodDate;
                    updatedAt: z.ZodDate;
                }, "strip", z.ZodTypeAny, {
                    status: "active" | "failed" | "paused";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    url: string;
                    events: string[];
                    lastTriggered: Date | null;
                    failureCount: number;
                }, {
                    status: "active" | "failed" | "paused";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    url: string;
                    events: string[];
                    lastTriggered: Date | null;
                    failureCount: number;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                webhooks: {
                    status: "active" | "failed" | "paused";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    url: string;
                    events: string[];
                    lastTriggered: Date | null;
                    failureCount: number;
                }[];
            }, {
                webhooks: {
                    status: "active" | "failed" | "paused";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    url: string;
                    events: string[];
                    lastTriggered: Date | null;
                    failureCount: number;
                }[];
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    getWebhook: {
        pathParams: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        summary: "Get webhook by ID";
        method: "GET";
        path: "/webhooks/:id";
        responses: {
            200: z.ZodObject<{
                id: z.ZodString;
                url: z.ZodString;
                events: z.ZodArray<z.ZodString, "many">;
                status: z.ZodEnum<["active", "paused", "failed"]>;
                lastTriggered: z.ZodNullable<z.ZodDate>;
                failureCount: z.ZodNumber;
                organizationId: z.ZodString;
            } & {
                createdAt: z.ZodDate;
                updatedAt: z.ZodDate;
            }, "strip", z.ZodTypeAny, {
                status: "active" | "failed" | "paused";
                id: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                url: string;
                events: string[];
                lastTriggered: Date | null;
                failureCount: number;
            }, {
                status: "active" | "failed" | "paused";
                id: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                url: string;
                events: string[];
                lastTriggered: Date | null;
                failureCount: number;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    createWebhook: {
        summary: "Create a new webhook";
        method: "POST";
        body: z.ZodObject<{
            url: z.ZodString;
            events: z.ZodArray<z.ZodEnum<["conversation.created", "conversation.resolved", "conversation.escalated", "escalation.created", "escalation.assigned", "escalation.resolved", "agent.action.completed"]>, "many">;
        }, "strip", z.ZodTypeAny, {
            url: string;
            events: ("conversation.created" | "conversation.resolved" | "conversation.escalated" | "escalation.created" | "escalation.assigned" | "escalation.resolved" | "agent.action.completed")[];
        }, {
            url: string;
            events: ("conversation.created" | "conversation.resolved" | "conversation.escalated" | "escalation.created" | "escalation.assigned" | "escalation.resolved" | "agent.action.completed")[];
        }>;
        path: "/webhooks";
        responses: {
            201: z.ZodObject<{
                id: z.ZodString;
                url: z.ZodString;
                events: z.ZodArray<z.ZodString, "many">;
                status: z.ZodEnum<["active", "paused", "failed"]>;
                lastTriggered: z.ZodNullable<z.ZodDate>;
                failureCount: z.ZodNumber;
                organizationId: z.ZodString;
            } & {
                createdAt: z.ZodDate;
                updatedAt: z.ZodDate;
            }, "strip", z.ZodTypeAny, {
                status: "active" | "failed" | "paused";
                id: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                url: string;
                events: string[];
                lastTriggered: Date | null;
                failureCount: number;
            }, {
                status: "active" | "failed" | "paused";
                id: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                url: string;
                events: string[];
                lastTriggered: Date | null;
                failureCount: number;
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    updateWebhook: {
        pathParams: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        summary: "Update webhook";
        method: "PATCH";
        body: z.ZodObject<{
            url: z.ZodOptional<z.ZodString>;
            events: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
            status: z.ZodOptional<z.ZodEnum<["active", "paused", "failed"]>>;
        }, "strip", z.ZodTypeAny, {
            status?: "active" | "failed" | "paused" | undefined;
            url?: string | undefined;
            events?: string[] | undefined;
        }, {
            status?: "active" | "failed" | "paused" | undefined;
            url?: string | undefined;
            events?: string[] | undefined;
        }>;
        path: "/webhooks/:id";
        responses: {
            200: z.ZodObject<{
                id: z.ZodString;
                url: z.ZodString;
                events: z.ZodArray<z.ZodString, "many">;
                status: z.ZodEnum<["active", "paused", "failed"]>;
                lastTriggered: z.ZodNullable<z.ZodDate>;
                failureCount: z.ZodNumber;
                organizationId: z.ZodString;
            } & {
                createdAt: z.ZodDate;
                updatedAt: z.ZodDate;
            }, "strip", z.ZodTypeAny, {
                status: "active" | "failed" | "paused";
                id: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                url: string;
                events: string[];
                lastTriggered: Date | null;
                failureCount: number;
            }, {
                status: "active" | "failed" | "paused";
                id: string;
                organizationId: string;
                createdAt: Date;
                updatedAt: Date;
                url: string;
                events: string[];
                lastTriggered: Date | null;
                failureCount: number;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    deleteWebhook: {
        pathParams: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        summary: "Delete webhook";
        method: "DELETE";
        body: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
        path: "/webhooks/:id";
        responses: {
            200: z.ZodObject<{
                message: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                message: string;
            }, {
                message: string;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    testWebhook: {
        pathParams: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        summary: "Test webhook with sample payload";
        method: "POST";
        body: z.ZodObject<{
            event: z.ZodString;
            payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
        }, "strip", z.ZodTypeAny, {
            event: string;
            payload: Record<string, unknown>;
        }, {
            event: string;
            payload: Record<string, unknown>;
        }>;
        path: "/webhooks/:id/test";
        responses: {
            200: z.ZodObject<{
                message: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                message: string;
            }, {
                message: string;
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            400: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
    getWebhookDeliveries: {
        pathParams: z.ZodObject<{
            id: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            id: string;
        }, {
            id: string;
        }>;
        query: z.ZodObject<{
            limit: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            limit: number;
        }, {
            limit?: number | undefined;
        }>;
        summary: "Get webhook delivery history";
        method: "GET";
        path: "/webhooks/:id/deliveries";
        responses: {
            200: z.ZodObject<{
                deliveries: z.ZodArray<z.ZodObject<{
                    id: z.ZodString;
                    event: z.ZodString;
                    status: z.ZodEnum<["pending", "delivered", "failed"]>;
                    statusCode: z.ZodNullable<z.ZodNumber>;
                    response: z.ZodNullable<z.ZodString>;
                    attempts: z.ZodNumber;
                    nextRetry: z.ZodNullable<z.ZodDate>;
                    deliveredAt: z.ZodNullable<z.ZodDate>;
                    createdAt: z.ZodDate;
                    webhookId: z.ZodString;
                }, "strip", z.ZodTypeAny, {
                    status: "pending" | "failed" | "delivered";
                    id: string;
                    createdAt: Date;
                    statusCode: number | null;
                    event: string;
                    response: string | null;
                    attempts: number;
                    nextRetry: Date | null;
                    deliveredAt: Date | null;
                    webhookId: string;
                }, {
                    status: "pending" | "failed" | "delivered";
                    id: string;
                    createdAt: Date;
                    statusCode: number | null;
                    event: string;
                    response: string | null;
                    attempts: number;
                    nextRetry: Date | null;
                    deliveredAt: Date | null;
                    webhookId: string;
                }>, "many">;
            }, "strip", z.ZodTypeAny, {
                deliveries: {
                    status: "pending" | "failed" | "delivered";
                    id: string;
                    createdAt: Date;
                    statusCode: number | null;
                    event: string;
                    response: string | null;
                    attempts: number;
                    nextRetry: Date | null;
                    deliveredAt: Date | null;
                    webhookId: string;
                }[];
            }, {
                deliveries: {
                    status: "pending" | "failed" | "delivered";
                    id: string;
                    createdAt: Date;
                    statusCode: number | null;
                    event: string;
                    response: string | null;
                    attempts: number;
                    nextRetry: Date | null;
                    deliveredAt: Date | null;
                    webhookId: string;
                }[];
            }>;
            404: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
            401: z.ZodObject<{
                message: z.ZodString;
                code: z.ZodOptional<z.ZodString>;
                details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
            }, "strip", z.ZodTypeAny, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }, {
                message: string;
                code?: string | undefined;
                details?: Record<string, unknown> | undefined;
            }>;
        };
    };
};

declare const apiContract: {
    auth: {
        login: {
            summary: "Login with email and password";
            method: "POST";
            body: zod.ZodObject<{
                email: zod.ZodString;
                password: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                email: string;
                password: string;
            }, {
                email: string;
                password: string;
            }>;
            path: "/api/v1/auth/login";
            responses: {
                200: zod.ZodObject<{
                    accessToken: zod.ZodString;
                    refreshToken: zod.ZodString;
                    expiresIn: zod.ZodNumber;
                    user: zod.ZodObject<{
                        id: zod.ZodString;
                        email: zod.ZodString;
                        name: zod.ZodString;
                        role: zod.ZodEnum<["admin", "agent", "viewer"]>;
                        organizationId: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        email: string;
                        id: string;
                        name: string;
                        role: "admin" | "agent" | "viewer";
                        organizationId: string;
                    }, {
                        email: string;
                        id: string;
                        name: string;
                        role: "admin" | "agent" | "viewer";
                        organizationId: string;
                    }>;
                }, "strip", zod.ZodTypeAny, {
                    accessToken: string;
                    refreshToken: string;
                    expiresIn: number;
                    user: {
                        email: string;
                        id: string;
                        name: string;
                        role: "admin" | "agent" | "viewer";
                        organizationId: string;
                    };
                }, {
                    accessToken: string;
                    refreshToken: string;
                    expiresIn: number;
                    user: {
                        email: string;
                        id: string;
                        name: string;
                        role: "admin" | "agent" | "viewer";
                        organizationId: string;
                    };
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        register: {
            summary: "Register a new organization and admin user";
            method: "POST";
            body: zod.ZodObject<{
                email: zod.ZodString;
                password: zod.ZodString;
                name: zod.ZodString;
                organizationName: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                email: string;
                password: string;
                name: string;
                organizationName: string;
            }, {
                email: string;
                password: string;
                name: string;
                organizationName: string;
            }>;
            path: "/api/v1/auth/register";
            responses: {
                201: zod.ZodObject<{
                    accessToken: zod.ZodString;
                    refreshToken: zod.ZodString;
                    expiresIn: zod.ZodNumber;
                    user: zod.ZodObject<{
                        id: zod.ZodString;
                        email: zod.ZodString;
                        name: zod.ZodString;
                        role: zod.ZodEnum<["admin", "agent", "viewer"]>;
                        organizationId: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        email: string;
                        id: string;
                        name: string;
                        role: "admin" | "agent" | "viewer";
                        organizationId: string;
                    }, {
                        email: string;
                        id: string;
                        name: string;
                        role: "admin" | "agent" | "viewer";
                        organizationId: string;
                    }>;
                }, "strip", zod.ZodTypeAny, {
                    accessToken: string;
                    refreshToken: string;
                    expiresIn: number;
                    user: {
                        email: string;
                        id: string;
                        name: string;
                        role: "admin" | "agent" | "viewer";
                        organizationId: string;
                    };
                }, {
                    accessToken: string;
                    refreshToken: string;
                    expiresIn: number;
                    user: {
                        email: string;
                        id: string;
                        name: string;
                        role: "admin" | "agent" | "viewer";
                        organizationId: string;
                    };
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                409: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        refreshToken: {
            summary: "Refresh access token";
            method: "POST";
            body: zod.ZodObject<{
                refreshToken: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                refreshToken: string;
            }, {
                refreshToken: string;
            }>;
            path: "/api/v1/auth/refresh";
            responses: {
                200: zod.ZodObject<{
                    accessToken: zod.ZodString;
                    expiresIn: zod.ZodNumber;
                }, "strip", zod.ZodTypeAny, {
                    accessToken: string;
                    expiresIn: number;
                }, {
                    accessToken: string;
                    expiresIn: number;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        changePassword: {
            summary: "Change user password";
            method: "POST";
            body: zod.ZodObject<{
                currentPassword: zod.ZodString;
                newPassword: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                currentPassword: string;
                newPassword: string;
            }, {
                currentPassword: string;
                newPassword: string;
            }>;
            path: "/api/v1/auth/change-password";
            responses: {
                200: zod.ZodObject<{
                    message: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                }, {
                    message: string;
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        createApiKey: {
            summary: "Create a new API key";
            method: "POST";
            body: zod.ZodObject<{
                name: zod.ZodString;
                permissions: zod.ZodArray<zod.ZodString, "many">;
                expiresAt: zod.ZodOptional<zod.ZodDate>;
            }, "strip", zod.ZodTypeAny, {
                name: string;
                permissions: string[];
                expiresAt?: Date | undefined;
            }, {
                name: string;
                permissions: string[];
                expiresAt?: Date | undefined;
            }>;
            path: "/api/v1/auth/api-keys";
            responses: {
                201: zod.ZodObject<{
                    id: zod.ZodString;
                    name: zod.ZodString;
                    key: zod.ZodString;
                    keyPrefix: zod.ZodString;
                    permissions: zod.ZodArray<zod.ZodString, "many">;
                    expiresAt: zod.ZodNullable<zod.ZodDate>;
                    lastUsedAt: zod.ZodNullable<zod.ZodDate>;
                } & {
                    createdAt: zod.ZodDate;
                    updatedAt: zod.ZodDate;
                }, "strip", zod.ZodTypeAny, {
                    id: string;
                    name: string;
                    permissions: string[];
                    expiresAt: Date | null;
                    key: string;
                    keyPrefix: string;
                    lastUsedAt: Date | null;
                    createdAt: Date;
                    updatedAt: Date;
                }, {
                    id: string;
                    name: string;
                    permissions: string[];
                    expiresAt: Date | null;
                    key: string;
                    keyPrefix: string;
                    lastUsedAt: Date | null;
                    createdAt: Date;
                    updatedAt: Date;
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        listApiKeys: {
            summary: "List all API keys";
            method: "GET";
            path: "/api/v1/auth/api-keys";
            responses: {
                200: zod.ZodObject<{
                    apiKeys: zod.ZodArray<zod.ZodObject<{
                        id: zod.ZodString;
                        name: zod.ZodString;
                        keyPrefix: zod.ZodString;
                        permissions: zod.ZodArray<zod.ZodString, "many">;
                        expiresAt: zod.ZodNullable<zod.ZodDate>;
                        lastUsedAt: zod.ZodNullable<zod.ZodDate>;
                    } & {
                        createdAt: zod.ZodDate;
                        updatedAt: zod.ZodDate;
                    }, "strip", zod.ZodTypeAny, {
                        id: string;
                        name: string;
                        permissions: string[];
                        expiresAt: Date | null;
                        keyPrefix: string;
                        lastUsedAt: Date | null;
                        createdAt: Date;
                        updatedAt: Date;
                    }, {
                        id: string;
                        name: string;
                        permissions: string[];
                        expiresAt: Date | null;
                        keyPrefix: string;
                        lastUsedAt: Date | null;
                        createdAt: Date;
                        updatedAt: Date;
                    }>, "many">;
                }, "strip", zod.ZodTypeAny, {
                    apiKeys: {
                        id: string;
                        name: string;
                        permissions: string[];
                        expiresAt: Date | null;
                        keyPrefix: string;
                        lastUsedAt: Date | null;
                        createdAt: Date;
                        updatedAt: Date;
                    }[];
                }, {
                    apiKeys: {
                        id: string;
                        name: string;
                        permissions: string[];
                        expiresAt: Date | null;
                        keyPrefix: string;
                        lastUsedAt: Date | null;
                        createdAt: Date;
                        updatedAt: Date;
                    }[];
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        deleteApiKey: {
            pathParams: zod.ZodObject<{
                id: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                id: string;
            }, {
                id: string;
            }>;
            summary: "Delete an API key";
            method: "DELETE";
            body: zod.ZodObject<{}, "strip", zod.ZodTypeAny, {}, {}>;
            path: "/api/v1/auth/api-keys/:id";
            responses: {
                200: zod.ZodObject<{
                    message: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                }, {
                    message: string;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        createPublicApiKey: {
            summary: "Create a public API key for frontend SDK";
            method: "POST";
            body: zod.ZodObject<{
                name: zod.ZodOptional<zod.ZodString>;
            }, "strip", zod.ZodTypeAny, {
                name?: string | undefined;
            }, {
                name?: string | undefined;
            }>;
            path: "/api/v1/auth/public-api-keys";
            responses: {
                201: zod.ZodObject<{
                    id: zod.ZodString;
                    name: zod.ZodString;
                    key: zod.ZodString;
                    keyPrefix: zod.ZodString;
                    permissions: zod.ZodArray<zod.ZodString, "many">;
                    expiresAt: zod.ZodNullable<zod.ZodDate>;
                    lastUsedAt: zod.ZodNullable<zod.ZodDate>;
                } & {
                    createdAt: zod.ZodDate;
                    updatedAt: zod.ZodDate;
                }, "strip", zod.ZodTypeAny, {
                    id: string;
                    name: string;
                    permissions: string[];
                    expiresAt: Date | null;
                    key: string;
                    keyPrefix: string;
                    lastUsedAt: Date | null;
                    createdAt: Date;
                    updatedAt: Date;
                }, {
                    id: string;
                    name: string;
                    permissions: string[];
                    expiresAt: Date | null;
                    key: string;
                    keyPrefix: string;
                    lastUsedAt: Date | null;
                    createdAt: Date;
                    updatedAt: Date;
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
    };
    public: {
        identify: {
            summary: "Identify user for persistent memory (frontend SDK)";
            method: "POST";
            body: zod.ZodObject<{
                userId: zod.ZodString;
                userData: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
            }, "strip", zod.ZodTypeAny, {
                userId: string;
                userData?: Record<string, unknown> | undefined;
            }, {
                userId: string;
                userData?: Record<string, unknown> | undefined;
            }>;
            path: "/api/v1/public/identify";
            responses: {
                200: zod.ZodObject<{
                    message: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                }, {
                    message: string;
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
    };
    knowledge: {
        uploadDocument: {
            summary: "Upload a knowledge document (PDF, Markdown, or Text)";
            method: "POST";
            contentType: "multipart/form-data";
            body: zod.ZodObject<{
                documentId: zod.ZodString;
                agentType: zod.ZodOptional<zod.ZodString>;
                file: zod.ZodAny;
            }, "strip", zod.ZodTypeAny, {
                documentId: string;
                agentType?: string | undefined;
                file?: any;
            }, {
                documentId: string;
                agentType?: string | undefined;
                file?: any;
            }>;
            path: "/api/v1/knowledge/upload";
            responses: {
                201: zod.ZodObject<{
                    id: zod.ZodString;
                    documentId: zod.ZodString;
                    filename: zod.ZodString;
                    contentType: zod.ZodString;
                    agentType: zod.ZodNullable<zod.ZodString>;
                    fileSize: zod.ZodNumber;
                    chunkCount: zod.ZodNumber;
                    status: zod.ZodString;
                    uploadedAt: zod.ZodDate;
                    processedAt: zod.ZodNullable<zod.ZodDate>;
                }, "strip", zod.ZodTypeAny, {
                    contentType: string;
                    status: string;
                    id: string;
                    documentId: string;
                    agentType: string | null;
                    filename: string;
                    fileSize: number;
                    chunkCount: number;
                    uploadedAt: Date;
                    processedAt: Date | null;
                }, {
                    contentType: string;
                    status: string;
                    id: string;
                    documentId: string;
                    agentType: string | null;
                    filename: string;
                    fileSize: number;
                    chunkCount: number;
                    uploadedAt: Date;
                    processedAt: Date | null;
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        listDocuments: {
            query: zod.ZodObject<{
                agentType: zod.ZodOptional<zod.ZodString>;
                status: zod.ZodOptional<zod.ZodString>;
            }, "strip", zod.ZodTypeAny, {
                status?: string | undefined;
                agentType?: string | undefined;
            }, {
                status?: string | undefined;
                agentType?: string | undefined;
            }>;
            summary: "List knowledge documents";
            method: "GET";
            path: "/api/v1/knowledge/documents";
            responses: {
                200: zod.ZodObject<{
                    documents: zod.ZodArray<zod.ZodObject<{
                        id: zod.ZodString;
                        documentId: zod.ZodString;
                        filename: zod.ZodString;
                        contentType: zod.ZodString;
                        agentType: zod.ZodNullable<zod.ZodString>;
                        fileSize: zod.ZodNumber;
                        chunkCount: zod.ZodNumber;
                        status: zod.ZodString;
                        uploadedAt: zod.ZodDate;
                        processedAt: zod.ZodNullable<zod.ZodDate>;
                    }, "strip", zod.ZodTypeAny, {
                        contentType: string;
                        status: string;
                        id: string;
                        documentId: string;
                        agentType: string | null;
                        filename: string;
                        fileSize: number;
                        chunkCount: number;
                        uploadedAt: Date;
                        processedAt: Date | null;
                    }, {
                        contentType: string;
                        status: string;
                        id: string;
                        documentId: string;
                        agentType: string | null;
                        filename: string;
                        fileSize: number;
                        chunkCount: number;
                        uploadedAt: Date;
                        processedAt: Date | null;
                    }>, "many">;
                }, "strip", zod.ZodTypeAny, {
                    documents: {
                        contentType: string;
                        status: string;
                        id: string;
                        documentId: string;
                        agentType: string | null;
                        filename: string;
                        fileSize: number;
                        chunkCount: number;
                        uploadedAt: Date;
                        processedAt: Date | null;
                    }[];
                }, {
                    documents: {
                        contentType: string;
                        status: string;
                        id: string;
                        documentId: string;
                        agentType: string | null;
                        filename: string;
                        fileSize: number;
                        chunkCount: number;
                        uploadedAt: Date;
                        processedAt: Date | null;
                    }[];
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        getDocument: {
            pathParams: zod.ZodObject<{
                id: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                id: string;
            }, {
                id: string;
            }>;
            summary: "Get knowledge document by ID";
            method: "GET";
            path: "/api/v1/knowledge/documents/:id";
            responses: {
                200: zod.ZodObject<{
                    id: zod.ZodString;
                    documentId: zod.ZodString;
                    filename: zod.ZodString;
                    contentType: zod.ZodString;
                    agentType: zod.ZodNullable<zod.ZodString>;
                    fileSize: zod.ZodNumber;
                    chunkCount: zod.ZodNumber;
                    status: zod.ZodString;
                    uploadedAt: zod.ZodDate;
                    processedAt: zod.ZodNullable<zod.ZodDate>;
                }, "strip", zod.ZodTypeAny, {
                    contentType: string;
                    status: string;
                    id: string;
                    documentId: string;
                    agentType: string | null;
                    filename: string;
                    fileSize: number;
                    chunkCount: number;
                    uploadedAt: Date;
                    processedAt: Date | null;
                }, {
                    contentType: string;
                    status: string;
                    id: string;
                    documentId: string;
                    agentType: string | null;
                    filename: string;
                    fileSize: number;
                    chunkCount: number;
                    uploadedAt: Date;
                    processedAt: Date | null;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        deleteDocument: {
            pathParams: zod.ZodObject<{
                id: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                id: string;
            }, {
                id: string;
            }>;
            summary: "Delete knowledge document and all its chunks";
            method: "DELETE";
            body: zod.ZodObject<{}, "strip", zod.ZodTypeAny, {}, {}>;
            path: "/api/v1/knowledge/documents/:id";
            responses: {
                200: zod.ZodObject<{
                    message: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                }, {
                    message: string;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        updateDocumentAgent: {
            pathParams: zod.ZodObject<{
                id: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                id: string;
            }, {
                id: string;
            }>;
            summary: "Update document agent assignment";
            method: "PATCH";
            body: zod.ZodObject<{
                agentType: zod.ZodNullable<zod.ZodString>;
            }, "strip", zod.ZodTypeAny, {
                agentType: string | null;
            }, {
                agentType: string | null;
            }>;
            path: "/api/v1/knowledge/documents/:id/agent";
            responses: {
                200: zod.ZodObject<{
                    id: zod.ZodString;
                    documentId: zod.ZodString;
                    filename: zod.ZodString;
                    contentType: zod.ZodString;
                    agentType: zod.ZodNullable<zod.ZodString>;
                    fileSize: zod.ZodNumber;
                    chunkCount: zod.ZodNumber;
                    status: zod.ZodString;
                    uploadedAt: zod.ZodDate;
                    processedAt: zod.ZodNullable<zod.ZodDate>;
                }, "strip", zod.ZodTypeAny, {
                    contentType: string;
                    status: string;
                    id: string;
                    documentId: string;
                    agentType: string | null;
                    filename: string;
                    fileSize: number;
                    chunkCount: number;
                    uploadedAt: Date;
                    processedAt: Date | null;
                }, {
                    contentType: string;
                    status: string;
                    id: string;
                    documentId: string;
                    agentType: string | null;
                    filename: string;
                    fileSize: number;
                    chunkCount: number;
                    uploadedAt: Date;
                    processedAt: Date | null;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
    };
    tools: {
        createTool: {
            summary: "Register a new external tool";
            method: "POST";
            body: zod.ZodObject<{
                name: zod.ZodString;
                description: zod.ZodString;
                endpointUrl: zod.ZodString;
                httpMethod: zod.ZodOptional<zod.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>>;
                bodySchema: zod.ZodRecord<zod.ZodString, zod.ZodUnknown>;
                headers: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodString>>;
                agentType: zod.ZodOptional<zod.ZodString>;
            }, "strip", zod.ZodTypeAny, {
                description: string;
                name: string;
                endpointUrl: string;
                bodySchema: Record<string, unknown>;
                headers?: Record<string, string> | undefined;
                agentType?: string | undefined;
                httpMethod?: "GET" | "POST" | "DELETE" | "PUT" | "PATCH" | undefined;
            }, {
                description: string;
                name: string;
                endpointUrl: string;
                bodySchema: Record<string, unknown>;
                headers?: Record<string, string> | undefined;
                agentType?: string | undefined;
                httpMethod?: "GET" | "POST" | "DELETE" | "PUT" | "PATCH" | undefined;
            }>;
            path: "/api/v1/tools";
            responses: {
                201: zod.ZodObject<{
                    id: zod.ZodString;
                    name: zod.ZodString;
                    description: zod.ZodString;
                    agentType: zod.ZodNullable<zod.ZodString>;
                    endpointUrl: zod.ZodString;
                    httpMethod: zod.ZodString;
                    bodySchema: zod.ZodRecord<zod.ZodString, zod.ZodUnknown>;
                    headers: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodString>>;
                    enabled: zod.ZodBoolean;
                    createdAt: zod.ZodDate;
                    updatedAt: zod.ZodDate;
                }, "strip", zod.ZodTypeAny, {
                    headers: Record<string, string> | null;
                    description: string;
                    id: string;
                    name: string;
                    createdAt: Date;
                    updatedAt: Date;
                    agentType: string | null;
                    endpointUrl: string;
                    httpMethod: string;
                    bodySchema: Record<string, unknown>;
                    enabled: boolean;
                }, {
                    headers: Record<string, string> | null;
                    description: string;
                    id: string;
                    name: string;
                    createdAt: Date;
                    updatedAt: Date;
                    agentType: string | null;
                    endpointUrl: string;
                    httpMethod: string;
                    bodySchema: Record<string, unknown>;
                    enabled: boolean;
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        listTools: {
            query: zod.ZodObject<{
                agentType: zod.ZodOptional<zod.ZodString>;
                enabled: zod.ZodOptional<zod.ZodString>;
            }, "strip", zod.ZodTypeAny, {
                agentType?: string | undefined;
                enabled?: string | undefined;
            }, {
                agentType?: string | undefined;
                enabled?: string | undefined;
            }>;
            summary: "List all registered tools";
            method: "GET";
            path: "/api/v1/tools";
            responses: {
                200: zod.ZodObject<{
                    tools: zod.ZodArray<zod.ZodObject<{
                        id: zod.ZodString;
                        name: zod.ZodString;
                        description: zod.ZodString;
                        agentType: zod.ZodNullable<zod.ZodString>;
                        endpointUrl: zod.ZodString;
                        httpMethod: zod.ZodString;
                        bodySchema: zod.ZodRecord<zod.ZodString, zod.ZodUnknown>;
                        headers: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodString>>;
                        enabled: zod.ZodBoolean;
                        createdAt: zod.ZodDate;
                        updatedAt: zod.ZodDate;
                    }, "strip", zod.ZodTypeAny, {
                        headers: Record<string, string> | null;
                        description: string;
                        id: string;
                        name: string;
                        createdAt: Date;
                        updatedAt: Date;
                        agentType: string | null;
                        endpointUrl: string;
                        httpMethod: string;
                        bodySchema: Record<string, unknown>;
                        enabled: boolean;
                    }, {
                        headers: Record<string, string> | null;
                        description: string;
                        id: string;
                        name: string;
                        createdAt: Date;
                        updatedAt: Date;
                        agentType: string | null;
                        endpointUrl: string;
                        httpMethod: string;
                        bodySchema: Record<string, unknown>;
                        enabled: boolean;
                    }>, "many">;
                }, "strip", zod.ZodTypeAny, {
                    tools: {
                        headers: Record<string, string> | null;
                        description: string;
                        id: string;
                        name: string;
                        createdAt: Date;
                        updatedAt: Date;
                        agentType: string | null;
                        endpointUrl: string;
                        httpMethod: string;
                        bodySchema: Record<string, unknown>;
                        enabled: boolean;
                    }[];
                }, {
                    tools: {
                        headers: Record<string, string> | null;
                        description: string;
                        id: string;
                        name: string;
                        createdAt: Date;
                        updatedAt: Date;
                        agentType: string | null;
                        endpointUrl: string;
                        httpMethod: string;
                        bodySchema: Record<string, unknown>;
                        enabled: boolean;
                    }[];
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        getTool: {
            pathParams: zod.ZodObject<{
                id: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                id: string;
            }, {
                id: string;
            }>;
            summary: "Get tool by ID";
            method: "GET";
            path: "/api/v1/tools/:id";
            responses: {
                200: zod.ZodObject<{
                    id: zod.ZodString;
                    name: zod.ZodString;
                    description: zod.ZodString;
                    agentType: zod.ZodNullable<zod.ZodString>;
                    endpointUrl: zod.ZodString;
                    httpMethod: zod.ZodString;
                    bodySchema: zod.ZodRecord<zod.ZodString, zod.ZodUnknown>;
                    headers: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodString>>;
                    enabled: zod.ZodBoolean;
                    createdAt: zod.ZodDate;
                    updatedAt: zod.ZodDate;
                }, "strip", zod.ZodTypeAny, {
                    headers: Record<string, string> | null;
                    description: string;
                    id: string;
                    name: string;
                    createdAt: Date;
                    updatedAt: Date;
                    agentType: string | null;
                    endpointUrl: string;
                    httpMethod: string;
                    bodySchema: Record<string, unknown>;
                    enabled: boolean;
                }, {
                    headers: Record<string, string> | null;
                    description: string;
                    id: string;
                    name: string;
                    createdAt: Date;
                    updatedAt: Date;
                    agentType: string | null;
                    endpointUrl: string;
                    httpMethod: string;
                    bodySchema: Record<string, unknown>;
                    enabled: boolean;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        updateTool: {
            pathParams: zod.ZodObject<{
                id: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                id: string;
            }, {
                id: string;
            }>;
            summary: "Update tool configuration";
            method: "PATCH";
            body: zod.ZodObject<{
                name: zod.ZodOptional<zod.ZodString>;
                description: zod.ZodOptional<zod.ZodString>;
                endpointUrl: zod.ZodOptional<zod.ZodString>;
                httpMethod: zod.ZodOptional<zod.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>>;
                bodySchema: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                headers: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodString>>;
                agentType: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
                enabled: zod.ZodOptional<zod.ZodBoolean>;
            }, "strip", zod.ZodTypeAny, {
                headers?: Record<string, string> | undefined;
                description?: string | undefined;
                name?: string | undefined;
                agentType?: string | null | undefined;
                endpointUrl?: string | undefined;
                httpMethod?: "GET" | "POST" | "DELETE" | "PUT" | "PATCH" | undefined;
                bodySchema?: Record<string, unknown> | undefined;
                enabled?: boolean | undefined;
            }, {
                headers?: Record<string, string> | undefined;
                description?: string | undefined;
                name?: string | undefined;
                agentType?: string | null | undefined;
                endpointUrl?: string | undefined;
                httpMethod?: "GET" | "POST" | "DELETE" | "PUT" | "PATCH" | undefined;
                bodySchema?: Record<string, unknown> | undefined;
                enabled?: boolean | undefined;
            }>;
            path: "/api/v1/tools/:id";
            responses: {
                200: zod.ZodObject<{
                    id: zod.ZodString;
                    name: zod.ZodString;
                    description: zod.ZodString;
                    agentType: zod.ZodNullable<zod.ZodString>;
                    endpointUrl: zod.ZodString;
                    httpMethod: zod.ZodString;
                    bodySchema: zod.ZodRecord<zod.ZodString, zod.ZodUnknown>;
                    headers: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodString>>;
                    enabled: zod.ZodBoolean;
                    createdAt: zod.ZodDate;
                    updatedAt: zod.ZodDate;
                }, "strip", zod.ZodTypeAny, {
                    headers: Record<string, string> | null;
                    description: string;
                    id: string;
                    name: string;
                    createdAt: Date;
                    updatedAt: Date;
                    agentType: string | null;
                    endpointUrl: string;
                    httpMethod: string;
                    bodySchema: Record<string, unknown>;
                    enabled: boolean;
                }, {
                    headers: Record<string, string> | null;
                    description: string;
                    id: string;
                    name: string;
                    createdAt: Date;
                    updatedAt: Date;
                    agentType: string | null;
                    endpointUrl: string;
                    httpMethod: string;
                    bodySchema: Record<string, unknown>;
                    enabled: boolean;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        deleteTool: {
            pathParams: zod.ZodObject<{
                id: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                id: string;
            }, {
                id: string;
            }>;
            summary: "Delete a tool";
            method: "DELETE";
            body: zod.ZodObject<{}, "strip", zod.ZodTypeAny, {}, {}>;
            path: "/api/v1/tools/:id";
            responses: {
                200: zod.ZodObject<{
                    message: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                }, {
                    message: string;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        executeTool: {
            pathParams: zod.ZodObject<{
                id: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                id: string;
            }, {
                id: string;
            }>;
            summary: "Execute a registered tool";
            method: "POST";
            body: zod.ZodObject<{
                body: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
            }, "strip", zod.ZodTypeAny, {
                body?: Record<string, unknown> | undefined;
            }, {
                body?: Record<string, unknown> | undefined;
            }>;
            path: "/api/v1/tools/:id/execute";
            responses: {
                200: zod.ZodObject<{
                    success: zod.ZodBoolean;
                    statusCode: zod.ZodNumber;
                    data: zod.ZodOptional<zod.ZodUnknown>;
                    error: zod.ZodOptional<zod.ZodString>;
                }, "strip", zod.ZodTypeAny, {
                    success: boolean;
                    statusCode: number;
                    data?: unknown;
                    error?: string | undefined;
                }, {
                    success: boolean;
                    statusCode: number;
                    data?: unknown;
                    error?: string | undefined;
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                500: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
    };
    conversations: {
        createConversation: {
            summary: "Create a new conversation";
            method: "POST";
            body: zod.ZodObject<{
                customerId: zod.ZodString;
                customerEmail: zod.ZodOptional<zod.ZodString>;
                customerName: zod.ZodOptional<zod.ZodString>;
                channel: zod.ZodDefault<zod.ZodEnum<["web", "mobile", "email", "slack", "api"]>>;
                priority: zod.ZodDefault<zod.ZodEnum<["low", "normal", "high", "urgent"]>>;
                metadata: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
            }, "strip", zod.ZodTypeAny, {
                customerId: string;
                channel: "email" | "web" | "mobile" | "slack" | "api";
                priority: "low" | "normal" | "high" | "urgent";
                metadata?: Record<string, unknown> | undefined;
                customerEmail?: string | undefined;
                customerName?: string | undefined;
            }, {
                customerId: string;
                metadata?: Record<string, unknown> | undefined;
                customerEmail?: string | undefined;
                customerName?: string | undefined;
                channel?: "email" | "web" | "mobile" | "slack" | "api" | undefined;
                priority?: "low" | "normal" | "high" | "urgent" | undefined;
            }>;
            path: "/api/v1/conversations";
            responses: {
                201: zod.ZodObject<{
                    id: zod.ZodString;
                    customerId: zod.ZodString;
                    customerEmail: zod.ZodNullable<zod.ZodString>;
                    customerName: zod.ZodNullable<zod.ZodString>;
                    channel: zod.ZodEnum<["web", "mobile", "email", "slack", "api"]>;
                    status: zod.ZodEnum<["active", "resolved", "escalated"]>;
                    priority: zod.ZodEnum<["low", "normal", "high", "urgent"]>;
                    sentiment: zod.ZodEnum<["positive", "neutral", "negative", "frustrated", "angry"]>;
                    effortScore: zod.ZodNullable<zod.ZodNumber>;
                    resolved: zod.ZodBoolean;
                    resolvedAt: zod.ZodNullable<zod.ZodDate>;
                    firstResponseAt: zod.ZodNullable<zod.ZodDate>;
                    contextSummary: zod.ZodNullable<zod.ZodString>;
                    metadata: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                    organizationId: zod.ZodString;
                } & {
                    createdAt: zod.ZodDate;
                    updatedAt: zod.ZodDate;
                }, "strip", zod.ZodTypeAny, {
                    metadata: Record<string, unknown> | null;
                    status: "active" | "resolved" | "escalated";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    customerId: string;
                    customerEmail: string | null;
                    customerName: string | null;
                    channel: "email" | "web" | "mobile" | "slack" | "api";
                    priority: "low" | "normal" | "high" | "urgent";
                    resolved: boolean;
                    sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
                    effortScore: number | null;
                    resolvedAt: Date | null;
                    firstResponseAt: Date | null;
                    contextSummary: string | null;
                }, {
                    metadata: Record<string, unknown> | null;
                    status: "active" | "resolved" | "escalated";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    customerId: string;
                    customerEmail: string | null;
                    customerName: string | null;
                    channel: "email" | "web" | "mobile" | "slack" | "api";
                    priority: "low" | "normal" | "high" | "urgent";
                    resolved: boolean;
                    sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
                    effortScore: number | null;
                    resolvedAt: Date | null;
                    firstResponseAt: Date | null;
                    contextSummary: string | null;
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        getConversation: {
            pathParams: zod.ZodObject<{
                id: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                id: string;
            }, {
                id: string;
            }>;
            summary: "Get conversation by ID with messages";
            method: "GET";
            path: "/api/v1/conversations/:id";
            responses: {
                200: zod.ZodObject<{
                    id: zod.ZodString;
                    customerId: zod.ZodString;
                    customerEmail: zod.ZodNullable<zod.ZodString>;
                    customerName: zod.ZodNullable<zod.ZodString>;
                    channel: zod.ZodEnum<["web", "mobile", "email", "slack", "api"]>;
                    status: zod.ZodEnum<["active", "resolved", "escalated"]>;
                    priority: zod.ZodEnum<["low", "normal", "high", "urgent"]>;
                    sentiment: zod.ZodEnum<["positive", "neutral", "negative", "frustrated", "angry"]>;
                    effortScore: zod.ZodNullable<zod.ZodNumber>;
                    resolved: zod.ZodBoolean;
                    resolvedAt: zod.ZodNullable<zod.ZodDate>;
                    firstResponseAt: zod.ZodNullable<zod.ZodDate>;
                    contextSummary: zod.ZodNullable<zod.ZodString>;
                    metadata: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                    organizationId: zod.ZodString;
                } & {
                    createdAt: zod.ZodDate;
                    updatedAt: zod.ZodDate;
                } & {
                    messages: zod.ZodArray<zod.ZodObject<{
                        id: zod.ZodString;
                        content: zod.ZodString;
                        role: zod.ZodEnum<["user", "assistant", "system"]>;
                        agentType: zod.ZodNullable<zod.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>>;
                        tokenCount: zod.ZodNumber;
                        cost: zod.ZodNumber;
                        sentiment: zod.ZodNullable<zod.ZodEnum<["positive", "neutral", "negative", "frustrated", "angry"]>>;
                        intent: zod.ZodNullable<zod.ZodString>;
                        metadata: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                    } & {
                        createdAt: zod.ZodDate;
                        updatedAt: zod.ZodDate;
                    }, "strip", zod.ZodTypeAny, {
                        metadata: Record<string, unknown> | null;
                        id: string;
                        role: "user" | "assistant" | "system";
                        createdAt: Date;
                        updatedAt: Date;
                        agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | null;
                        sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry" | null;
                        content: string;
                        tokenCount: number;
                        cost: number;
                        intent: string | null;
                    }, {
                        metadata: Record<string, unknown> | null;
                        id: string;
                        role: "user" | "assistant" | "system";
                        createdAt: Date;
                        updatedAt: Date;
                        agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | null;
                        sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry" | null;
                        content: string;
                        tokenCount: number;
                        cost: number;
                        intent: string | null;
                    }>, "many">;
                }, "strip", zod.ZodTypeAny, {
                    metadata: Record<string, unknown> | null;
                    status: "active" | "resolved" | "escalated";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    customerId: string;
                    customerEmail: string | null;
                    customerName: string | null;
                    channel: "email" | "web" | "mobile" | "slack" | "api";
                    priority: "low" | "normal" | "high" | "urgent";
                    resolved: boolean;
                    sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
                    effortScore: number | null;
                    resolvedAt: Date | null;
                    firstResponseAt: Date | null;
                    contextSummary: string | null;
                    messages: {
                        metadata: Record<string, unknown> | null;
                        id: string;
                        role: "user" | "assistant" | "system";
                        createdAt: Date;
                        updatedAt: Date;
                        agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | null;
                        sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry" | null;
                        content: string;
                        tokenCount: number;
                        cost: number;
                        intent: string | null;
                    }[];
                }, {
                    metadata: Record<string, unknown> | null;
                    status: "active" | "resolved" | "escalated";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    customerId: string;
                    customerEmail: string | null;
                    customerName: string | null;
                    channel: "email" | "web" | "mobile" | "slack" | "api";
                    priority: "low" | "normal" | "high" | "urgent";
                    resolved: boolean;
                    sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
                    effortScore: number | null;
                    resolvedAt: Date | null;
                    firstResponseAt: Date | null;
                    contextSummary: string | null;
                    messages: {
                        metadata: Record<string, unknown> | null;
                        id: string;
                        role: "user" | "assistant" | "system";
                        createdAt: Date;
                        updatedAt: Date;
                        agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | null;
                        sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry" | null;
                        content: string;
                        tokenCount: number;
                        cost: number;
                        intent: string | null;
                    }[];
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        listConversations: {
            query: zod.ZodObject<{
                page: zod.ZodDefault<zod.ZodNumber>;
                limit: zod.ZodDefault<zod.ZodNumber>;
            } & {
                status: zod.ZodOptional<zod.ZodEnum<["active", "resolved", "escalated"]>>;
                priority: zod.ZodOptional<zod.ZodEnum<["low", "normal", "high", "urgent"]>>;
                channel: zod.ZodOptional<zod.ZodEnum<["web", "mobile", "email", "slack", "api"]>>;
                customerId: zod.ZodOptional<zod.ZodString>;
                fromDate: zod.ZodOptional<zod.ZodDate>;
                toDate: zod.ZodOptional<zod.ZodDate>;
            }, "strip", zod.ZodTypeAny, {
                page: number;
                limit: number;
                status?: "active" | "resolved" | "escalated" | undefined;
                customerId?: string | undefined;
                channel?: "email" | "web" | "mobile" | "slack" | "api" | undefined;
                priority?: "low" | "normal" | "high" | "urgent" | undefined;
                fromDate?: Date | undefined;
                toDate?: Date | undefined;
            }, {
                status?: "active" | "resolved" | "escalated" | undefined;
                customerId?: string | undefined;
                channel?: "email" | "web" | "mobile" | "slack" | "api" | undefined;
                priority?: "low" | "normal" | "high" | "urgent" | undefined;
                page?: number | undefined;
                limit?: number | undefined;
                fromDate?: Date | undefined;
                toDate?: Date | undefined;
            }>;
            summary: "List conversations with pagination and filters";
            method: "GET";
            path: "/api/v1/conversations";
            responses: {
                200: zod.ZodObject<{
                    conversations: zod.ZodArray<zod.ZodObject<{
                        id: zod.ZodString;
                        customerId: zod.ZodString;
                        customerEmail: zod.ZodNullable<zod.ZodString>;
                        customerName: zod.ZodNullable<zod.ZodString>;
                        channel: zod.ZodEnum<["web", "mobile", "email", "slack", "api"]>;
                        status: zod.ZodEnum<["active", "resolved", "escalated"]>;
                        priority: zod.ZodEnum<["low", "normal", "high", "urgent"]>;
                        sentiment: zod.ZodEnum<["positive", "neutral", "negative", "frustrated", "angry"]>;
                        effortScore: zod.ZodNullable<zod.ZodNumber>;
                        resolved: zod.ZodBoolean;
                        resolvedAt: zod.ZodNullable<zod.ZodDate>;
                        firstResponseAt: zod.ZodNullable<zod.ZodDate>;
                        contextSummary: zod.ZodNullable<zod.ZodString>;
                        metadata: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                        organizationId: zod.ZodString;
                    } & {
                        createdAt: zod.ZodDate;
                        updatedAt: zod.ZodDate;
                    }, "strip", zod.ZodTypeAny, {
                        metadata: Record<string, unknown> | null;
                        status: "active" | "resolved" | "escalated";
                        id: string;
                        organizationId: string;
                        createdAt: Date;
                        updatedAt: Date;
                        customerId: string;
                        customerEmail: string | null;
                        customerName: string | null;
                        channel: "email" | "web" | "mobile" | "slack" | "api";
                        priority: "low" | "normal" | "high" | "urgent";
                        resolved: boolean;
                        sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
                        effortScore: number | null;
                        resolvedAt: Date | null;
                        firstResponseAt: Date | null;
                        contextSummary: string | null;
                    }, {
                        metadata: Record<string, unknown> | null;
                        status: "active" | "resolved" | "escalated";
                        id: string;
                        organizationId: string;
                        createdAt: Date;
                        updatedAt: Date;
                        customerId: string;
                        customerEmail: string | null;
                        customerName: string | null;
                        channel: "email" | "web" | "mobile" | "slack" | "api";
                        priority: "low" | "normal" | "high" | "urgent";
                        resolved: boolean;
                        sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
                        effortScore: number | null;
                        resolvedAt: Date | null;
                        firstResponseAt: Date | null;
                        contextSummary: string | null;
                    }>, "many">;
                    pagination: zod.ZodObject<{
                        page: zod.ZodNumber;
                        limit: zod.ZodNumber;
                        total: zod.ZodNumber;
                        totalPages: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        page: number;
                        limit: number;
                        total: number;
                        totalPages: number;
                    }, {
                        page: number;
                        limit: number;
                        total: number;
                        totalPages: number;
                    }>;
                }, "strip", zod.ZodTypeAny, {
                    conversations: {
                        metadata: Record<string, unknown> | null;
                        status: "active" | "resolved" | "escalated";
                        id: string;
                        organizationId: string;
                        createdAt: Date;
                        updatedAt: Date;
                        customerId: string;
                        customerEmail: string | null;
                        customerName: string | null;
                        channel: "email" | "web" | "mobile" | "slack" | "api";
                        priority: "low" | "normal" | "high" | "urgent";
                        resolved: boolean;
                        sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
                        effortScore: number | null;
                        resolvedAt: Date | null;
                        firstResponseAt: Date | null;
                        contextSummary: string | null;
                    }[];
                    pagination: {
                        page: number;
                        limit: number;
                        total: number;
                        totalPages: number;
                    };
                }, {
                    conversations: {
                        metadata: Record<string, unknown> | null;
                        status: "active" | "resolved" | "escalated";
                        id: string;
                        organizationId: string;
                        createdAt: Date;
                        updatedAt: Date;
                        customerId: string;
                        customerEmail: string | null;
                        customerName: string | null;
                        channel: "email" | "web" | "mobile" | "slack" | "api";
                        priority: "low" | "normal" | "high" | "urgent";
                        resolved: boolean;
                        sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
                        effortScore: number | null;
                        resolvedAt: Date | null;
                        firstResponseAt: Date | null;
                        contextSummary: string | null;
                    }[];
                    pagination: {
                        page: number;
                        limit: number;
                        total: number;
                        totalPages: number;
                    };
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        updateConversation: {
            pathParams: zod.ZodObject<{
                id: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                id: string;
            }, {
                id: string;
            }>;
            summary: "Update conversation";
            method: "PATCH";
            body: zod.ZodObject<{
                status: zod.ZodOptional<zod.ZodEnum<["active", "resolved", "escalated"]>>;
                priority: zod.ZodOptional<zod.ZodEnum<["low", "normal", "high", "urgent"]>>;
                effortScore: zod.ZodOptional<zod.ZodNumber>;
                metadata: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
            }, "strip", zod.ZodTypeAny, {
                metadata?: Record<string, unknown> | undefined;
                status?: "active" | "resolved" | "escalated" | undefined;
                priority?: "low" | "normal" | "high" | "urgent" | undefined;
                effortScore?: number | undefined;
            }, {
                metadata?: Record<string, unknown> | undefined;
                status?: "active" | "resolved" | "escalated" | undefined;
                priority?: "low" | "normal" | "high" | "urgent" | undefined;
                effortScore?: number | undefined;
            }>;
            path: "/api/v1/conversations/:id";
            responses: {
                200: zod.ZodObject<{
                    id: zod.ZodString;
                    customerId: zod.ZodString;
                    customerEmail: zod.ZodNullable<zod.ZodString>;
                    customerName: zod.ZodNullable<zod.ZodString>;
                    channel: zod.ZodEnum<["web", "mobile", "email", "slack", "api"]>;
                    status: zod.ZodEnum<["active", "resolved", "escalated"]>;
                    priority: zod.ZodEnum<["low", "normal", "high", "urgent"]>;
                    sentiment: zod.ZodEnum<["positive", "neutral", "negative", "frustrated", "angry"]>;
                    effortScore: zod.ZodNullable<zod.ZodNumber>;
                    resolved: zod.ZodBoolean;
                    resolvedAt: zod.ZodNullable<zod.ZodDate>;
                    firstResponseAt: zod.ZodNullable<zod.ZodDate>;
                    contextSummary: zod.ZodNullable<zod.ZodString>;
                    metadata: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                    organizationId: zod.ZodString;
                } & {
                    createdAt: zod.ZodDate;
                    updatedAt: zod.ZodDate;
                }, "strip", zod.ZodTypeAny, {
                    metadata: Record<string, unknown> | null;
                    status: "active" | "resolved" | "escalated";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    customerId: string;
                    customerEmail: string | null;
                    customerName: string | null;
                    channel: "email" | "web" | "mobile" | "slack" | "api";
                    priority: "low" | "normal" | "high" | "urgent";
                    resolved: boolean;
                    sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
                    effortScore: number | null;
                    resolvedAt: Date | null;
                    firstResponseAt: Date | null;
                    contextSummary: string | null;
                }, {
                    metadata: Record<string, unknown> | null;
                    status: "active" | "resolved" | "escalated";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    customerId: string;
                    customerEmail: string | null;
                    customerName: string | null;
                    channel: "email" | "web" | "mobile" | "slack" | "api";
                    priority: "low" | "normal" | "high" | "urgent";
                    resolved: boolean;
                    sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry";
                    effortScore: number | null;
                    resolvedAt: Date | null;
                    firstResponseAt: Date | null;
                    contextSummary: string | null;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        sendMessage: {
            pathParams: zod.ZodObject<{
                id: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                id: string;
            }, {
                id: string;
            }>;
            summary: "Send a message in a conversation";
            method: "POST";
            body: zod.ZodObject<{
                content: zod.ZodString;
                role: zod.ZodDefault<zod.ZodEnum<["user", "assistant"]>>;
                metadata: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
            }, "strip", zod.ZodTypeAny, {
                role: "user" | "assistant";
                content: string;
                metadata?: Record<string, unknown> | undefined;
            }, {
                content: string;
                metadata?: Record<string, unknown> | undefined;
                role?: "user" | "assistant" | undefined;
            }>;
            path: "/api/v1/conversations/:id/messages";
            responses: {
                201: zod.ZodObject<{
                    id: zod.ZodString;
                    content: zod.ZodString;
                    role: zod.ZodEnum<["user", "assistant", "system"]>;
                    agentType: zod.ZodNullable<zod.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>>;
                    tokenCount: zod.ZodNumber;
                    cost: zod.ZodNumber;
                    sentiment: zod.ZodNullable<zod.ZodEnum<["positive", "neutral", "negative", "frustrated", "angry"]>>;
                    intent: zod.ZodNullable<zod.ZodString>;
                    metadata: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                } & {
                    createdAt: zod.ZodDate;
                    updatedAt: zod.ZodDate;
                }, "strip", zod.ZodTypeAny, {
                    metadata: Record<string, unknown> | null;
                    id: string;
                    role: "user" | "assistant" | "system";
                    createdAt: Date;
                    updatedAt: Date;
                    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | null;
                    sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry" | null;
                    content: string;
                    tokenCount: number;
                    cost: number;
                    intent: string | null;
                }, {
                    metadata: Record<string, unknown> | null;
                    id: string;
                    role: "user" | "assistant" | "system";
                    createdAt: Date;
                    updatedAt: Date;
                    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | null;
                    sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry" | null;
                    content: string;
                    tokenCount: number;
                    cost: number;
                    intent: string | null;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        getMessages: {
            pathParams: zod.ZodObject<{
                id: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                id: string;
            }, {
                id: string;
            }>;
            query: zod.ZodObject<{
                page: zod.ZodDefault<zod.ZodNumber>;
                limit: zod.ZodDefault<zod.ZodNumber>;
            }, "strip", zod.ZodTypeAny, {
                page: number;
                limit: number;
            }, {
                page?: number | undefined;
                limit?: number | undefined;
            }>;
            summary: "Get messages for a conversation";
            method: "GET";
            path: "/api/v1/conversations/:id/messages";
            responses: {
                200: zod.ZodObject<{
                    messages: zod.ZodArray<zod.ZodObject<{
                        id: zod.ZodString;
                        content: zod.ZodString;
                        role: zod.ZodEnum<["user", "assistant", "system"]>;
                        agentType: zod.ZodNullable<zod.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>>;
                        tokenCount: zod.ZodNumber;
                        cost: zod.ZodNumber;
                        sentiment: zod.ZodNullable<zod.ZodEnum<["positive", "neutral", "negative", "frustrated", "angry"]>>;
                        intent: zod.ZodNullable<zod.ZodString>;
                        metadata: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                    } & {
                        createdAt: zod.ZodDate;
                        updatedAt: zod.ZodDate;
                    }, "strip", zod.ZodTypeAny, {
                        metadata: Record<string, unknown> | null;
                        id: string;
                        role: "user" | "assistant" | "system";
                        createdAt: Date;
                        updatedAt: Date;
                        agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | null;
                        sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry" | null;
                        content: string;
                        tokenCount: number;
                        cost: number;
                        intent: string | null;
                    }, {
                        metadata: Record<string, unknown> | null;
                        id: string;
                        role: "user" | "assistant" | "system";
                        createdAt: Date;
                        updatedAt: Date;
                        agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | null;
                        sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry" | null;
                        content: string;
                        tokenCount: number;
                        cost: number;
                        intent: string | null;
                    }>, "many">;
                    pagination: zod.ZodObject<{
                        page: zod.ZodNumber;
                        limit: zod.ZodNumber;
                        total: zod.ZodNumber;
                        totalPages: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        page: number;
                        limit: number;
                        total: number;
                        totalPages: number;
                    }, {
                        page: number;
                        limit: number;
                        total: number;
                        totalPages: number;
                    }>;
                }, "strip", zod.ZodTypeAny, {
                    messages: {
                        metadata: Record<string, unknown> | null;
                        id: string;
                        role: "user" | "assistant" | "system";
                        createdAt: Date;
                        updatedAt: Date;
                        agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | null;
                        sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry" | null;
                        content: string;
                        tokenCount: number;
                        cost: number;
                        intent: string | null;
                    }[];
                    pagination: {
                        page: number;
                        limit: number;
                        total: number;
                        totalPages: number;
                    };
                }, {
                    messages: {
                        metadata: Record<string, unknown> | null;
                        id: string;
                        role: "user" | "assistant" | "system";
                        createdAt: Date;
                        updatedAt: Date;
                        agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | null;
                        sentiment: "positive" | "neutral" | "negative" | "frustrated" | "angry" | null;
                        content: string;
                        tokenCount: number;
                        cost: number;
                        intent: string | null;
                    }[];
                    pagination: {
                        page: number;
                        limit: number;
                        total: number;
                        totalPages: number;
                    };
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
    };
    agents: {
        getSystemStatus: {
            summary: "Get live agentic system status";
            method: "GET";
            path: "/api/v1/agents/status";
            responses: {
                200: zod.ZodObject<{
                    orchestratorLoad: zod.ZodNumber;
                    resolverActionsPerHour: zod.ZodNumber;
                    agents: zod.ZodArray<zod.ZodObject<{
                        type: zod.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>;
                        status: zod.ZodEnum<["active", "idle"]>;
                    }, "strip", zod.ZodTypeAny, {
                        type: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                        status: "active" | "idle";
                    }, {
                        type: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                        status: "active" | "idle";
                    }>, "many">;
                }, "strip", zod.ZodTypeAny, {
                    orchestratorLoad: number;
                    resolverActionsPerHour: number;
                    agents: {
                        type: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                        status: "active" | "idle";
                    }[];
                }, {
                    orchestratorLoad: number;
                    resolverActionsPerHour: number;
                    agents: {
                        type: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                        status: "active" | "idle";
                    }[];
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        getAgentStatus: {
            pathParams: zod.ZodObject<{
                agentType: zod.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>;
            }, "strip", zod.ZodTypeAny, {
                agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
            }, {
                agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
            }>;
            summary: "Get status for a specific agent";
            method: "GET";
            path: "/api/v1/agents/:agentType/status";
            responses: {
                200: zod.ZodObject<{
                    agentType: zod.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>;
                    status: zod.ZodEnum<["active", "idle", "error"]>;
                    currentLoad: zod.ZodNumber;
                    actionsPerHour: zod.ZodNumber;
                    averageResponseTime: zod.ZodNumber;
                    errorRate: zod.ZodNumber;
                }, "strip", zod.ZodTypeAny, {
                    status: "error" | "active" | "idle";
                    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                    currentLoad: number;
                    actionsPerHour: number;
                    averageResponseTime: number;
                    errorRate: number;
                }, {
                    status: "error" | "active" | "idle";
                    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                    currentLoad: number;
                    actionsPerHour: number;
                    averageResponseTime: number;
                    errorRate: number;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        getAgentMetrics: {
            pathParams: zod.ZodObject<{
                agentType: zod.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>;
            }, "strip", zod.ZodTypeAny, {
                agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
            }, {
                agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
            }>;
            query: zod.ZodObject<{
                from: zod.ZodDate;
                to: zod.ZodDate;
            }, "strip", zod.ZodTypeAny, {
                from: Date;
                to: Date;
            }, {
                from: Date;
                to: Date;
            }>;
            summary: "Get performance metrics for an agent";
            method: "GET";
            path: "/api/v1/agents/:agentType/metrics";
            responses: {
                200: zod.ZodObject<{
                    agentType: zod.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>;
                    totalActions: zod.ZodNumber;
                    successfulActions: zod.ZodNumber;
                    failedActions: zod.ZodNumber;
                    averageDuration: zod.ZodNumber;
                    totalCost: zod.ZodNumber;
                    totalTokens: zod.ZodNumber;
                    period: zod.ZodObject<{
                        from: zod.ZodDate;
                        to: zod.ZodDate;
                    }, "strip", zod.ZodTypeAny, {
                        from: Date;
                        to: Date;
                    }, {
                        from: Date;
                        to: Date;
                    }>;
                }, "strip", zod.ZodTypeAny, {
                    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                    totalActions: number;
                    successfulActions: number;
                    failedActions: number;
                    averageDuration: number;
                    totalCost: number;
                    totalTokens: number;
                    period: {
                        from: Date;
                        to: Date;
                    };
                }, {
                    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                    totalActions: number;
                    successfulActions: number;
                    failedActions: number;
                    averageDuration: number;
                    totalCost: number;
                    totalTokens: number;
                    period: {
                        from: Date;
                        to: Date;
                    };
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        getAgentConfig: {
            pathParams: zod.ZodObject<{
                agentType: zod.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>;
            }, "strip", zod.ZodTypeAny, {
                agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
            }, {
                agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
            }>;
            summary: "Get agent configuration";
            method: "GET";
            path: "/api/v1/agents/:agentType/config";
            responses: {
                200: zod.ZodObject<{
                    agentType: zod.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>;
                    enabled: zod.ZodBoolean;
                    maxConcurrent: zod.ZodDefault<zod.ZodNumber>;
                    timeout: zod.ZodDefault<zod.ZodNumber>;
                    retryAttempts: zod.ZodDefault<zod.ZodNumber>;
                    llmModel: zod.ZodDefault<zod.ZodString>;
                    temperature: zod.ZodDefault<zod.ZodNumber>;
                    systemPrompt: zod.ZodOptional<zod.ZodString>;
                    tools: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
                }, "strip", zod.ZodTypeAny, {
                    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                    enabled: boolean;
                    maxConcurrent: number;
                    timeout: number;
                    retryAttempts: number;
                    llmModel: string;
                    temperature: number;
                    tools?: string[] | undefined;
                    systemPrompt?: string | undefined;
                }, {
                    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                    enabled: boolean;
                    tools?: string[] | undefined;
                    maxConcurrent?: number | undefined;
                    timeout?: number | undefined;
                    retryAttempts?: number | undefined;
                    llmModel?: string | undefined;
                    temperature?: number | undefined;
                    systemPrompt?: string | undefined;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        updateAgentConfig: {
            pathParams: zod.ZodObject<{
                agentType: zod.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>;
            }, "strip", zod.ZodTypeAny, {
                agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
            }, {
                agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
            }>;
            summary: "Update agent configuration";
            method: "PATCH";
            body: zod.ZodObject<{
                agentType: zod.ZodOptional<zod.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>>;
                enabled: zod.ZodOptional<zod.ZodBoolean>;
                maxConcurrent: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
                timeout: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
                retryAttempts: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
                llmModel: zod.ZodOptional<zod.ZodDefault<zod.ZodString>>;
                temperature: zod.ZodOptional<zod.ZodDefault<zod.ZodNumber>>;
                systemPrompt: zod.ZodOptional<zod.ZodOptional<zod.ZodString>>;
                tools: zod.ZodOptional<zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>>;
            }, "strip", zod.ZodTypeAny, {
                agentType?: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | undefined;
                enabled?: boolean | undefined;
                tools?: string[] | undefined;
                maxConcurrent?: number | undefined;
                timeout?: number | undefined;
                retryAttempts?: number | undefined;
                llmModel?: string | undefined;
                temperature?: number | undefined;
                systemPrompt?: string | undefined;
            }, {
                agentType?: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | undefined;
                enabled?: boolean | undefined;
                tools?: string[] | undefined;
                maxConcurrent?: number | undefined;
                timeout?: number | undefined;
                retryAttempts?: number | undefined;
                llmModel?: string | undefined;
                temperature?: number | undefined;
                systemPrompt?: string | undefined;
            }>;
            path: "/api/v1/agents/:agentType/config";
            responses: {
                200: zod.ZodObject<{
                    agentType: zod.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>;
                    enabled: zod.ZodBoolean;
                    maxConcurrent: zod.ZodDefault<zod.ZodNumber>;
                    timeout: zod.ZodDefault<zod.ZodNumber>;
                    retryAttempts: zod.ZodDefault<zod.ZodNumber>;
                    llmModel: zod.ZodDefault<zod.ZodString>;
                    temperature: zod.ZodDefault<zod.ZodNumber>;
                    systemPrompt: zod.ZodOptional<zod.ZodString>;
                    tools: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
                }, "strip", zod.ZodTypeAny, {
                    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                    enabled: boolean;
                    maxConcurrent: number;
                    timeout: number;
                    retryAttempts: number;
                    llmModel: string;
                    temperature: number;
                    tools?: string[] | undefined;
                    systemPrompt?: string | undefined;
                }, {
                    agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                    enabled: boolean;
                    tools?: string[] | undefined;
                    maxConcurrent?: number | undefined;
                    timeout?: number | undefined;
                    retryAttempts?: number | undefined;
                    llmModel?: string | undefined;
                    temperature?: number | undefined;
                    systemPrompt?: string | undefined;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        listAgentActions: {
            query: zod.ZodObject<{
                page: zod.ZodDefault<zod.ZodNumber>;
                limit: zod.ZodDefault<zod.ZodNumber>;
            } & {
                conversationId: zod.ZodOptional<zod.ZodString>;
                agentType: zod.ZodOptional<zod.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>>;
                status: zod.ZodOptional<zod.ZodEnum<["pending", "in_progress", "completed", "failed"]>>;
            }, "strip", zod.ZodTypeAny, {
                page: number;
                limit: number;
                status?: "pending" | "in_progress" | "completed" | "failed" | undefined;
                agentType?: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | undefined;
                conversationId?: string | undefined;
            }, {
                status?: "pending" | "in_progress" | "completed" | "failed" | undefined;
                agentType?: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator" | undefined;
                page?: number | undefined;
                limit?: number | undefined;
                conversationId?: string | undefined;
            }>;
            summary: "List agent actions with filters";
            method: "GET";
            path: "/api/v1/agents/actions";
            responses: {
                200: zod.ZodObject<{
                    actions: zod.ZodArray<zod.ZodObject<{
                        id: zod.ZodString;
                        agentType: zod.ZodEnum<["orchestrator", "listener", "resolver", "technical", "billing", "product", "anticipator"]>;
                        action: zod.ZodString;
                        status: zod.ZodEnum<["pending", "in_progress", "completed", "failed"]>;
                        input: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                        output: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                        toolName: zod.ZodNullable<zod.ZodString>;
                        toolParams: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                        toolResult: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                        reasoning: zod.ZodNullable<zod.ZodString>;
                        tokenCount: zod.ZodNumber;
                        cost: zod.ZodNumber;
                        duration: zod.ZodNullable<zod.ZodNumber>;
                        error: zod.ZodNullable<zod.ZodString>;
                        conversationId: zod.ZodString;
                        completedAt: zod.ZodNullable<zod.ZodDate>;
                    } & {
                        createdAt: zod.ZodDate;
                        updatedAt: zod.ZodDate;
                    }, "strip", zod.ZodTypeAny, {
                        status: "pending" | "in_progress" | "completed" | "failed";
                        id: string;
                        createdAt: Date;
                        updatedAt: Date;
                        agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                        error: string | null;
                        tokenCount: number;
                        cost: number;
                        conversationId: string;
                        action: string;
                        input: Record<string, unknown> | null;
                        output: Record<string, unknown> | null;
                        toolName: string | null;
                        toolParams: Record<string, unknown> | null;
                        toolResult: Record<string, unknown> | null;
                        reasoning: string | null;
                        duration: number | null;
                        completedAt: Date | null;
                    }, {
                        status: "pending" | "in_progress" | "completed" | "failed";
                        id: string;
                        createdAt: Date;
                        updatedAt: Date;
                        agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                        error: string | null;
                        tokenCount: number;
                        cost: number;
                        conversationId: string;
                        action: string;
                        input: Record<string, unknown> | null;
                        output: Record<string, unknown> | null;
                        toolName: string | null;
                        toolParams: Record<string, unknown> | null;
                        toolResult: Record<string, unknown> | null;
                        reasoning: string | null;
                        duration: number | null;
                        completedAt: Date | null;
                    }>, "many">;
                    pagination: zod.ZodObject<{
                        page: zod.ZodNumber;
                        limit: zod.ZodNumber;
                        total: zod.ZodNumber;
                        totalPages: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        page: number;
                        limit: number;
                        total: number;
                        totalPages: number;
                    }, {
                        page: number;
                        limit: number;
                        total: number;
                        totalPages: number;
                    }>;
                }, "strip", zod.ZodTypeAny, {
                    pagination: {
                        page: number;
                        limit: number;
                        total: number;
                        totalPages: number;
                    };
                    actions: {
                        status: "pending" | "in_progress" | "completed" | "failed";
                        id: string;
                        createdAt: Date;
                        updatedAt: Date;
                        agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                        error: string | null;
                        tokenCount: number;
                        cost: number;
                        conversationId: string;
                        action: string;
                        input: Record<string, unknown> | null;
                        output: Record<string, unknown> | null;
                        toolName: string | null;
                        toolParams: Record<string, unknown> | null;
                        toolResult: Record<string, unknown> | null;
                        reasoning: string | null;
                        duration: number | null;
                        completedAt: Date | null;
                    }[];
                }, {
                    pagination: {
                        page: number;
                        limit: number;
                        total: number;
                        totalPages: number;
                    };
                    actions: {
                        status: "pending" | "in_progress" | "completed" | "failed";
                        id: string;
                        createdAt: Date;
                        updatedAt: Date;
                        agentType: "orchestrator" | "listener" | "resolver" | "technical" | "billing" | "product" | "anticipator";
                        error: string | null;
                        tokenCount: number;
                        cost: number;
                        conversationId: string;
                        action: string;
                        input: Record<string, unknown> | null;
                        output: Record<string, unknown> | null;
                        toolName: string | null;
                        toolParams: Record<string, unknown> | null;
                        toolResult: Record<string, unknown> | null;
                        reasoning: string | null;
                        duration: number | null;
                        completedAt: Date | null;
                    }[];
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
    };
    escalations: {
        createEscalation: {
            summary: "Create a new escalation";
            method: "POST";
            body: zod.ZodObject<{
                conversationId: zod.ZodString;
                reason: zod.ZodString;
                priority: zod.ZodDefault<zod.ZodEnum<["low", "normal", "high", "urgent"]>>;
                aiSummary: zod.ZodString;
                customerContext: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
            }, "strip", zod.ZodTypeAny, {
                priority: "low" | "normal" | "high" | "urgent";
                conversationId: string;
                reason: string;
                aiSummary: string;
                customerContext?: Record<string, unknown> | undefined;
            }, {
                conversationId: string;
                reason: string;
                aiSummary: string;
                priority?: "low" | "normal" | "high" | "urgent" | undefined;
                customerContext?: Record<string, unknown> | undefined;
            }>;
            path: "/api/v1/escalations";
            responses: {
                201: zod.ZodObject<{
                    id: zod.ZodString;
                    reason: zod.ZodString;
                    priority: zod.ZodEnum<["low", "normal", "high", "urgent"]>;
                    status: zod.ZodEnum<["new", "assigned", "in_progress", "resolved"]>;
                    aiSummary: zod.ZodString;
                    customerContext: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                    assignedAt: zod.ZodNullable<zod.ZodDate>;
                    resolvedAt: zod.ZodNullable<zod.ZodDate>;
                    resolution: zod.ZodNullable<zod.ZodString>;
                    conversationId: zod.ZodString;
                    organizationId: zod.ZodString;
                    assignedToId: zod.ZodNullable<zod.ZodString>;
                    assignedTo: zod.ZodNullable<zod.ZodObject<{
                        id: zod.ZodString;
                        name: zod.ZodString;
                        email: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        email: string;
                        id: string;
                        name: string;
                    }, {
                        email: string;
                        id: string;
                        name: string;
                    }>>;
                } & {
                    createdAt: zod.ZodDate;
                    updatedAt: zod.ZodDate;
                }, "strip", zod.ZodTypeAny, {
                    status: "resolved" | "in_progress" | "new" | "assigned";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    priority: "low" | "normal" | "high" | "urgent";
                    resolvedAt: Date | null;
                    conversationId: string;
                    reason: string;
                    aiSummary: string;
                    customerContext: Record<string, unknown> | null;
                    assignedAt: Date | null;
                    resolution: string | null;
                    assignedToId: string | null;
                    assignedTo: {
                        email: string;
                        id: string;
                        name: string;
                    } | null;
                }, {
                    status: "resolved" | "in_progress" | "new" | "assigned";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    priority: "low" | "normal" | "high" | "urgent";
                    resolvedAt: Date | null;
                    conversationId: string;
                    reason: string;
                    aiSummary: string;
                    customerContext: Record<string, unknown> | null;
                    assignedAt: Date | null;
                    resolution: string | null;
                    assignedToId: string | null;
                    assignedTo: {
                        email: string;
                        id: string;
                        name: string;
                    } | null;
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        getEscalation: {
            pathParams: zod.ZodObject<{
                id: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                id: string;
            }, {
                id: string;
            }>;
            summary: "Get escalation by ID";
            method: "GET";
            path: "/api/v1/escalations/:id";
            responses: {
                200: zod.ZodObject<{
                    id: zod.ZodString;
                    reason: zod.ZodString;
                    priority: zod.ZodEnum<["low", "normal", "high", "urgent"]>;
                    status: zod.ZodEnum<["new", "assigned", "in_progress", "resolved"]>;
                    aiSummary: zod.ZodString;
                    customerContext: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                    assignedAt: zod.ZodNullable<zod.ZodDate>;
                    resolvedAt: zod.ZodNullable<zod.ZodDate>;
                    resolution: zod.ZodNullable<zod.ZodString>;
                    conversationId: zod.ZodString;
                    organizationId: zod.ZodString;
                    assignedToId: zod.ZodNullable<zod.ZodString>;
                    assignedTo: zod.ZodNullable<zod.ZodObject<{
                        id: zod.ZodString;
                        name: zod.ZodString;
                        email: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        email: string;
                        id: string;
                        name: string;
                    }, {
                        email: string;
                        id: string;
                        name: string;
                    }>>;
                } & {
                    createdAt: zod.ZodDate;
                    updatedAt: zod.ZodDate;
                }, "strip", zod.ZodTypeAny, {
                    status: "resolved" | "in_progress" | "new" | "assigned";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    priority: "low" | "normal" | "high" | "urgent";
                    resolvedAt: Date | null;
                    conversationId: string;
                    reason: string;
                    aiSummary: string;
                    customerContext: Record<string, unknown> | null;
                    assignedAt: Date | null;
                    resolution: string | null;
                    assignedToId: string | null;
                    assignedTo: {
                        email: string;
                        id: string;
                        name: string;
                    } | null;
                }, {
                    status: "resolved" | "in_progress" | "new" | "assigned";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    priority: "low" | "normal" | "high" | "urgent";
                    resolvedAt: Date | null;
                    conversationId: string;
                    reason: string;
                    aiSummary: string;
                    customerContext: Record<string, unknown> | null;
                    assignedAt: Date | null;
                    resolution: string | null;
                    assignedToId: string | null;
                    assignedTo: {
                        email: string;
                        id: string;
                        name: string;
                    } | null;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        listEscalations: {
            query: zod.ZodObject<{
                page: zod.ZodDefault<zod.ZodNumber>;
                limit: zod.ZodDefault<zod.ZodNumber>;
            } & {
                status: zod.ZodOptional<zod.ZodEnum<["new", "assigned", "in_progress", "resolved"]>>;
                priority: zod.ZodOptional<zod.ZodEnum<["low", "normal", "high", "urgent"]>>;
                assignedToId: zod.ZodOptional<zod.ZodString>;
                fromDate: zod.ZodOptional<zod.ZodDate>;
                toDate: zod.ZodOptional<zod.ZodDate>;
            }, "strip", zod.ZodTypeAny, {
                page: number;
                limit: number;
                status?: "resolved" | "in_progress" | "new" | "assigned" | undefined;
                priority?: "low" | "normal" | "high" | "urgent" | undefined;
                fromDate?: Date | undefined;
                toDate?: Date | undefined;
                assignedToId?: string | undefined;
            }, {
                status?: "resolved" | "in_progress" | "new" | "assigned" | undefined;
                priority?: "low" | "normal" | "high" | "urgent" | undefined;
                page?: number | undefined;
                limit?: number | undefined;
                fromDate?: Date | undefined;
                toDate?: Date | undefined;
                assignedToId?: string | undefined;
            }>;
            summary: "List escalations with pagination and filters";
            method: "GET";
            path: "/api/v1/escalations";
            responses: {
                200: zod.ZodObject<{
                    escalations: zod.ZodArray<zod.ZodObject<{
                        id: zod.ZodString;
                        reason: zod.ZodString;
                        priority: zod.ZodEnum<["low", "normal", "high", "urgent"]>;
                        status: zod.ZodEnum<["new", "assigned", "in_progress", "resolved"]>;
                        aiSummary: zod.ZodString;
                        customerContext: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                        assignedAt: zod.ZodNullable<zod.ZodDate>;
                        resolvedAt: zod.ZodNullable<zod.ZodDate>;
                        resolution: zod.ZodNullable<zod.ZodString>;
                        conversationId: zod.ZodString;
                        organizationId: zod.ZodString;
                        assignedToId: zod.ZodNullable<zod.ZodString>;
                        assignedTo: zod.ZodNullable<zod.ZodObject<{
                            id: zod.ZodString;
                            name: zod.ZodString;
                            email: zod.ZodString;
                        }, "strip", zod.ZodTypeAny, {
                            email: string;
                            id: string;
                            name: string;
                        }, {
                            email: string;
                            id: string;
                            name: string;
                        }>>;
                    } & {
                        createdAt: zod.ZodDate;
                        updatedAt: zod.ZodDate;
                    }, "strip", zod.ZodTypeAny, {
                        status: "resolved" | "in_progress" | "new" | "assigned";
                        id: string;
                        organizationId: string;
                        createdAt: Date;
                        updatedAt: Date;
                        priority: "low" | "normal" | "high" | "urgent";
                        resolvedAt: Date | null;
                        conversationId: string;
                        reason: string;
                        aiSummary: string;
                        customerContext: Record<string, unknown> | null;
                        assignedAt: Date | null;
                        resolution: string | null;
                        assignedToId: string | null;
                        assignedTo: {
                            email: string;
                            id: string;
                            name: string;
                        } | null;
                    }, {
                        status: "resolved" | "in_progress" | "new" | "assigned";
                        id: string;
                        organizationId: string;
                        createdAt: Date;
                        updatedAt: Date;
                        priority: "low" | "normal" | "high" | "urgent";
                        resolvedAt: Date | null;
                        conversationId: string;
                        reason: string;
                        aiSummary: string;
                        customerContext: Record<string, unknown> | null;
                        assignedAt: Date | null;
                        resolution: string | null;
                        assignedToId: string | null;
                        assignedTo: {
                            email: string;
                            id: string;
                            name: string;
                        } | null;
                    }>, "many">;
                    pagination: zod.ZodObject<{
                        page: zod.ZodNumber;
                        limit: zod.ZodNumber;
                        total: zod.ZodNumber;
                        totalPages: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        page: number;
                        limit: number;
                        total: number;
                        totalPages: number;
                    }, {
                        page: number;
                        limit: number;
                        total: number;
                        totalPages: number;
                    }>;
                }, "strip", zod.ZodTypeAny, {
                    pagination: {
                        page: number;
                        limit: number;
                        total: number;
                        totalPages: number;
                    };
                    escalations: {
                        status: "resolved" | "in_progress" | "new" | "assigned";
                        id: string;
                        organizationId: string;
                        createdAt: Date;
                        updatedAt: Date;
                        priority: "low" | "normal" | "high" | "urgent";
                        resolvedAt: Date | null;
                        conversationId: string;
                        reason: string;
                        aiSummary: string;
                        customerContext: Record<string, unknown> | null;
                        assignedAt: Date | null;
                        resolution: string | null;
                        assignedToId: string | null;
                        assignedTo: {
                            email: string;
                            id: string;
                            name: string;
                        } | null;
                    }[];
                }, {
                    pagination: {
                        page: number;
                        limit: number;
                        total: number;
                        totalPages: number;
                    };
                    escalations: {
                        status: "resolved" | "in_progress" | "new" | "assigned";
                        id: string;
                        organizationId: string;
                        createdAt: Date;
                        updatedAt: Date;
                        priority: "low" | "normal" | "high" | "urgent";
                        resolvedAt: Date | null;
                        conversationId: string;
                        reason: string;
                        aiSummary: string;
                        customerContext: Record<string, unknown> | null;
                        assignedAt: Date | null;
                        resolution: string | null;
                        assignedToId: string | null;
                        assignedTo: {
                            email: string;
                            id: string;
                            name: string;
                        } | null;
                    }[];
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        updateEscalation: {
            pathParams: zod.ZodObject<{
                id: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                id: string;
            }, {
                id: string;
            }>;
            summary: "Update escalation";
            method: "PATCH";
            body: zod.ZodObject<{
                status: zod.ZodOptional<zod.ZodEnum<["new", "assigned", "in_progress", "resolved"]>>;
                priority: zod.ZodOptional<zod.ZodEnum<["low", "normal", "high", "urgent"]>>;
                assignedToId: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
                resolution: zod.ZodOptional<zod.ZodString>;
            }, "strip", zod.ZodTypeAny, {
                status?: "resolved" | "in_progress" | "new" | "assigned" | undefined;
                priority?: "low" | "normal" | "high" | "urgent" | undefined;
                resolution?: string | undefined;
                assignedToId?: string | null | undefined;
            }, {
                status?: "resolved" | "in_progress" | "new" | "assigned" | undefined;
                priority?: "low" | "normal" | "high" | "urgent" | undefined;
                resolution?: string | undefined;
                assignedToId?: string | null | undefined;
            }>;
            path: "/api/v1/escalations/:id";
            responses: {
                200: zod.ZodObject<{
                    id: zod.ZodString;
                    reason: zod.ZodString;
                    priority: zod.ZodEnum<["low", "normal", "high", "urgent"]>;
                    status: zod.ZodEnum<["new", "assigned", "in_progress", "resolved"]>;
                    aiSummary: zod.ZodString;
                    customerContext: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                    assignedAt: zod.ZodNullable<zod.ZodDate>;
                    resolvedAt: zod.ZodNullable<zod.ZodDate>;
                    resolution: zod.ZodNullable<zod.ZodString>;
                    conversationId: zod.ZodString;
                    organizationId: zod.ZodString;
                    assignedToId: zod.ZodNullable<zod.ZodString>;
                    assignedTo: zod.ZodNullable<zod.ZodObject<{
                        id: zod.ZodString;
                        name: zod.ZodString;
                        email: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        email: string;
                        id: string;
                        name: string;
                    }, {
                        email: string;
                        id: string;
                        name: string;
                    }>>;
                } & {
                    createdAt: zod.ZodDate;
                    updatedAt: zod.ZodDate;
                }, "strip", zod.ZodTypeAny, {
                    status: "resolved" | "in_progress" | "new" | "assigned";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    priority: "low" | "normal" | "high" | "urgent";
                    resolvedAt: Date | null;
                    conversationId: string;
                    reason: string;
                    aiSummary: string;
                    customerContext: Record<string, unknown> | null;
                    assignedAt: Date | null;
                    resolution: string | null;
                    assignedToId: string | null;
                    assignedTo: {
                        email: string;
                        id: string;
                        name: string;
                    } | null;
                }, {
                    status: "resolved" | "in_progress" | "new" | "assigned";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    priority: "low" | "normal" | "high" | "urgent";
                    resolvedAt: Date | null;
                    conversationId: string;
                    reason: string;
                    aiSummary: string;
                    customerContext: Record<string, unknown> | null;
                    assignedAt: Date | null;
                    resolution: string | null;
                    assignedToId: string | null;
                    assignedTo: {
                        email: string;
                        id: string;
                        name: string;
                    } | null;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        assignEscalation: {
            pathParams: zod.ZodObject<{
                id: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                id: string;
            }, {
                id: string;
            }>;
            summary: "Assign escalation to a user";
            method: "POST";
            body: zod.ZodObject<{
                userId: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                userId: string;
            }, {
                userId: string;
            }>;
            path: "/api/v1/escalations/:id/assign";
            responses: {
                200: zod.ZodObject<{
                    id: zod.ZodString;
                    reason: zod.ZodString;
                    priority: zod.ZodEnum<["low", "normal", "high", "urgent"]>;
                    status: zod.ZodEnum<["new", "assigned", "in_progress", "resolved"]>;
                    aiSummary: zod.ZodString;
                    customerContext: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                    assignedAt: zod.ZodNullable<zod.ZodDate>;
                    resolvedAt: zod.ZodNullable<zod.ZodDate>;
                    resolution: zod.ZodNullable<zod.ZodString>;
                    conversationId: zod.ZodString;
                    organizationId: zod.ZodString;
                    assignedToId: zod.ZodNullable<zod.ZodString>;
                    assignedTo: zod.ZodNullable<zod.ZodObject<{
                        id: zod.ZodString;
                        name: zod.ZodString;
                        email: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        email: string;
                        id: string;
                        name: string;
                    }, {
                        email: string;
                        id: string;
                        name: string;
                    }>>;
                } & {
                    createdAt: zod.ZodDate;
                    updatedAt: zod.ZodDate;
                }, "strip", zod.ZodTypeAny, {
                    status: "resolved" | "in_progress" | "new" | "assigned";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    priority: "low" | "normal" | "high" | "urgent";
                    resolvedAt: Date | null;
                    conversationId: string;
                    reason: string;
                    aiSummary: string;
                    customerContext: Record<string, unknown> | null;
                    assignedAt: Date | null;
                    resolution: string | null;
                    assignedToId: string | null;
                    assignedTo: {
                        email: string;
                        id: string;
                        name: string;
                    } | null;
                }, {
                    status: "resolved" | "in_progress" | "new" | "assigned";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    priority: "low" | "normal" | "high" | "urgent";
                    resolvedAt: Date | null;
                    conversationId: string;
                    reason: string;
                    aiSummary: string;
                    customerContext: Record<string, unknown> | null;
                    assignedAt: Date | null;
                    resolution: string | null;
                    assignedToId: string | null;
                    assignedTo: {
                        email: string;
                        id: string;
                        name: string;
                    } | null;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        resolveEscalation: {
            pathParams: zod.ZodObject<{
                id: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                id: string;
            }, {
                id: string;
            }>;
            summary: "Mark escalation as resolved";
            method: "POST";
            body: zod.ZodObject<{
                resolution: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                resolution: string;
            }, {
                resolution: string;
            }>;
            path: "/api/v1/escalations/:id/resolve";
            responses: {
                200: zod.ZodObject<{
                    id: zod.ZodString;
                    reason: zod.ZodString;
                    priority: zod.ZodEnum<["low", "normal", "high", "urgent"]>;
                    status: zod.ZodEnum<["new", "assigned", "in_progress", "resolved"]>;
                    aiSummary: zod.ZodString;
                    customerContext: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                    assignedAt: zod.ZodNullable<zod.ZodDate>;
                    resolvedAt: zod.ZodNullable<zod.ZodDate>;
                    resolution: zod.ZodNullable<zod.ZodString>;
                    conversationId: zod.ZodString;
                    organizationId: zod.ZodString;
                    assignedToId: zod.ZodNullable<zod.ZodString>;
                    assignedTo: zod.ZodNullable<zod.ZodObject<{
                        id: zod.ZodString;
                        name: zod.ZodString;
                        email: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        email: string;
                        id: string;
                        name: string;
                    }, {
                        email: string;
                        id: string;
                        name: string;
                    }>>;
                } & {
                    createdAt: zod.ZodDate;
                    updatedAt: zod.ZodDate;
                }, "strip", zod.ZodTypeAny, {
                    status: "resolved" | "in_progress" | "new" | "assigned";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    priority: "low" | "normal" | "high" | "urgent";
                    resolvedAt: Date | null;
                    conversationId: string;
                    reason: string;
                    aiSummary: string;
                    customerContext: Record<string, unknown> | null;
                    assignedAt: Date | null;
                    resolution: string | null;
                    assignedToId: string | null;
                    assignedTo: {
                        email: string;
                        id: string;
                        name: string;
                    } | null;
                }, {
                    status: "resolved" | "in_progress" | "new" | "assigned";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    priority: "low" | "normal" | "high" | "urgent";
                    resolvedAt: Date | null;
                    conversationId: string;
                    reason: string;
                    aiSummary: string;
                    customerContext: Record<string, unknown> | null;
                    assignedAt: Date | null;
                    resolution: string | null;
                    assignedToId: string | null;
                    assignedTo: {
                        email: string;
                        id: string;
                        name: string;
                    } | null;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
    };
    analytics: {
        getDashboardMetrics: {
            query: zod.ZodObject<{
                period: zod.ZodDefault<zod.ZodEnum<["7d", "30d", "90d"]>>;
            }, "strip", zod.ZodTypeAny, {
                period: "7d" | "30d" | "90d";
            }, {
                period?: "7d" | "30d" | "90d" | undefined;
            }>;
            summary: "Get dashboard metrics (FCR, CES, EVI, ROI)";
            method: "GET";
            path: "/api/v1/analytics/dashboard";
            responses: {
                200: zod.ZodObject<{
                    firstContactResolution: zod.ZodObject<{
                        value: zod.ZodNumber;
                        change: zod.ZodNumber;
                        changeType: zod.ZodEnum<["increase", "decrease"]>;
                    }, "strip", zod.ZodTypeAny, {
                        value: number;
                        change: number;
                        changeType: "increase" | "decrease";
                    }, {
                        value: number;
                        change: number;
                        changeType: "increase" | "decrease";
                    }>;
                    customerEffortScore: zod.ZodObject<{
                        value: zod.ZodNumber;
                        change: zod.ZodNumber;
                        changeType: zod.ZodEnum<["increase", "decrease"]>;
                    }, "strip", zod.ZodTypeAny, {
                        value: number;
                        change: number;
                        changeType: "increase" | "decrease";
                    }, {
                        value: number;
                        change: number;
                        changeType: "increase" | "decrease";
                    }>;
                    emotionalValueIndex: zod.ZodObject<{
                        value: zod.ZodNumber;
                        change: zod.ZodNumber;
                        changeType: zod.ZodEnum<["increase", "decrease"]>;
                    }, "strip", zod.ZodTypeAny, {
                        value: number;
                        change: number;
                        changeType: "increase" | "decrease";
                    }, {
                        value: number;
                        change: number;
                        changeType: "increase" | "decrease";
                    }>;
                    supportROI: zod.ZodObject<{
                        value: zod.ZodNumber;
                        retainedRevenue: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        value: number;
                        retainedRevenue: number;
                    }, {
                        value: number;
                        retainedRevenue: number;
                    }>;
                }, "strip", zod.ZodTypeAny, {
                    firstContactResolution: {
                        value: number;
                        change: number;
                        changeType: "increase" | "decrease";
                    };
                    customerEffortScore: {
                        value: number;
                        change: number;
                        changeType: "increase" | "decrease";
                    };
                    emotionalValueIndex: {
                        value: number;
                        change: number;
                        changeType: "increase" | "decrease";
                    };
                    supportROI: {
                        value: number;
                        retainedRevenue: number;
                    };
                }, {
                    firstContactResolution: {
                        value: number;
                        change: number;
                        changeType: "increase" | "decrease";
                    };
                    customerEffortScore: {
                        value: number;
                        change: number;
                        changeType: "increase" | "decrease";
                    };
                    emotionalValueIndex: {
                        value: number;
                        change: number;
                        changeType: "increase" | "decrease";
                    };
                    supportROI: {
                        value: number;
                        retainedRevenue: number;
                    };
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        getSentimentOverTime: {
            query: zod.ZodObject<{
                from: zod.ZodDate;
                to: zod.ZodDate;
                granularity: zod.ZodDefault<zod.ZodEnum<["hour", "day", "week", "month"]>>;
            }, "strip", zod.ZodTypeAny, {
                from: Date;
                to: Date;
                granularity: "hour" | "day" | "week" | "month";
            }, {
                from: Date;
                to: Date;
                granularity?: "hour" | "day" | "week" | "month" | undefined;
            }>;
            summary: "Get sentiment (EVI) over time";
            method: "GET";
            path: "/api/v1/analytics/sentiment";
            responses: {
                200: zod.ZodObject<{
                    dataPoints: zod.ZodArray<zod.ZodObject<{
                        date: zod.ZodDate;
                        evi: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        date: Date;
                        evi: number;
                    }, {
                        date: Date;
                        evi: number;
                    }>, "many">;
                }, "strip", zod.ZodTypeAny, {
                    dataPoints: {
                        date: Date;
                        evi: number;
                    }[];
                }, {
                    dataPoints: {
                        date: Date;
                        evi: number;
                    }[];
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        getFrustrationDrivers: {
            query: zod.ZodObject<{
                limit: zod.ZodDefault<zod.ZodNumber>;
            }, "strip", zod.ZodTypeAny, {
                limit: number;
            }, {
                limit?: number | undefined;
            }>;
            summary: "Get top frustration drivers";
            method: "GET";
            path: "/api/v1/analytics/frustration-drivers";
            responses: {
                200: zod.ZodObject<{
                    drivers: zod.ZodArray<zod.ZodObject<{
                        topic: zod.ZodString;
                        mentions: zod.ZodNumber;
                        percentage: zod.ZodNumber;
                        severity: zod.ZodEnum<["low", "medium", "high"]>;
                    }, "strip", zod.ZodTypeAny, {
                        topic: string;
                        mentions: number;
                        percentage: number;
                        severity: "low" | "high" | "medium";
                    }, {
                        topic: string;
                        mentions: number;
                        percentage: number;
                        severity: "low" | "high" | "medium";
                    }>, "many">;
                }, "strip", zod.ZodTypeAny, {
                    drivers: {
                        topic: string;
                        mentions: number;
                        percentage: number;
                        severity: "low" | "high" | "medium";
                    }[];
                }, {
                    drivers: {
                        topic: string;
                        mentions: number;
                        percentage: number;
                        severity: "low" | "high" | "medium";
                    }[];
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        getEmergingIssues: {
            query: zod.ZodObject<{
                limit: zod.ZodDefault<zod.ZodNumber>;
            }, "strip", zod.ZodTypeAny, {
                limit: number;
            }, {
                limit?: number | undefined;
            }>;
            summary: "Get emerging issues trending upward";
            method: "GET";
            path: "/api/v1/analytics/emerging-issues";
            responses: {
                200: zod.ZodObject<{
                    issues: zod.ZodArray<zod.ZodObject<{
                        topic: zod.ZodString;
                        mentions: zod.ZodNumber;
                        growthRate: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        topic: string;
                        mentions: number;
                        growthRate: number;
                    }, {
                        topic: string;
                        mentions: number;
                        growthRate: number;
                    }>, "many">;
                }, "strip", zod.ZodTypeAny, {
                    issues: {
                        topic: string;
                        mentions: number;
                        growthRate: number;
                    }[];
                }, {
                    issues: {
                        topic: string;
                        mentions: number;
                        growthRate: number;
                    }[];
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        getConversationMetrics: {
            pathParams: zod.ZodObject<{
                id: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                id: string;
            }, {
                id: string;
            }>;
            summary: "Get detailed metrics for a specific conversation";
            method: "GET";
            path: "/api/v1/analytics/conversations/:id/metrics";
            responses: {
                200: zod.ZodObject<{
                    id: zod.ZodString;
                    conversationId: zod.ZodString;
                    firstContactResolution: zod.ZodBoolean;
                    effortScore: zod.ZodNullable<zod.ZodNumber>;
                    emotionalValueIndex: zod.ZodNullable<zod.ZodNumber>;
                    totalMessages: zod.ZodNumber;
                    totalTokens: zod.ZodNumber;
                    totalCost: zod.ZodNumber;
                    agentsInvolved: zod.ZodArray<zod.ZodString, "many">;
                    toolsUsed: zod.ZodArray<zod.ZodString, "many">;
                    durationSeconds: zod.ZodNullable<zod.ZodNumber>;
                    resolutionTimeSeconds: zod.ZodNullable<zod.ZodNumber>;
                    calculatedAt: zod.ZodDate;
                }, "strip", zod.ZodTypeAny, {
                    id: string;
                    effortScore: number | null;
                    totalCost: number;
                    totalTokens: number;
                    conversationId: string;
                    firstContactResolution: boolean;
                    emotionalValueIndex: number | null;
                    totalMessages: number;
                    agentsInvolved: string[];
                    toolsUsed: string[];
                    durationSeconds: number | null;
                    resolutionTimeSeconds: number | null;
                    calculatedAt: Date;
                }, {
                    id: string;
                    effortScore: number | null;
                    totalCost: number;
                    totalTokens: number;
                    conversationId: string;
                    firstContactResolution: boolean;
                    emotionalValueIndex: number | null;
                    totalMessages: number;
                    agentsInvolved: string[];
                    toolsUsed: string[];
                    durationSeconds: number | null;
                    resolutionTimeSeconds: number | null;
                    calculatedAt: Date;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        getFinOpsMetrics: {
            query: zod.ZodObject<{
                period: zod.ZodDefault<zod.ZodEnum<["7d", "30d", "90d"]>>;
            }, "strip", zod.ZodTypeAny, {
                period: "7d" | "30d" | "90d";
            }, {
                period?: "7d" | "30d" | "90d" | undefined;
            }>;
            summary: "Get FinOps cost tracking metrics";
            method: "GET";
            path: "/api/v1/analytics/finops";
            responses: {
                200: zod.ZodObject<{
                    totalSpend: zod.ZodObject<{
                        value: zod.ZodNumber;
                        period: zod.ZodString;
                        change: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        value: number;
                        period: string;
                        change: number;
                    }, {
                        value: number;
                        period: string;
                        change: number;
                    }>;
                    resolvedConversations: zod.ZodObject<{
                        value: zod.ZodNumber;
                        change: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        value: number;
                        change: number;
                    }, {
                        value: number;
                        change: number;
                    }>;
                    avgCostPerResolution: zod.ZodObject<{
                        value: zod.ZodNumber;
                        change: zod.ZodNumber;
                        changeType: zod.ZodEnum<["increase", "decrease"]>;
                    }, "strip", zod.ZodTypeAny, {
                        value: number;
                        change: number;
                        changeType: "increase" | "decrease";
                    }, {
                        value: number;
                        change: number;
                        changeType: "increase" | "decrease";
                    }>;
                    dataEgressFees: zod.ZodObject<{
                        value: zod.ZodNumber;
                        poweredBy: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        value: number;
                        poweredBy: string;
                    }, {
                        value: number;
                        poweredBy: string;
                    }>;
                    spendOverTime: zod.ZodArray<zod.ZodObject<{
                        date: zod.ZodDate;
                        spend: zod.ZodNumber;
                        limit: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        date: Date;
                        limit: number;
                        spend: number;
                    }, {
                        date: Date;
                        limit: number;
                        spend: number;
                    }>, "many">;
                    usageBreakdown: zod.ZodArray<zod.ZodObject<{
                        conversationId: zod.ZodString;
                        date: zod.ZodDate;
                        agentsInvolved: zod.ZodArray<zod.ZodString, "many">;
                        tokens: zod.ZodNumber;
                        totalCost: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        date: Date;
                        totalCost: number;
                        conversationId: string;
                        agentsInvolved: string[];
                        tokens: number;
                    }, {
                        date: Date;
                        totalCost: number;
                        conversationId: string;
                        agentsInvolved: string[];
                        tokens: number;
                    }>, "many">;
                }, "strip", zod.ZodTypeAny, {
                    totalSpend: {
                        value: number;
                        period: string;
                        change: number;
                    };
                    resolvedConversations: {
                        value: number;
                        change: number;
                    };
                    avgCostPerResolution: {
                        value: number;
                        change: number;
                        changeType: "increase" | "decrease";
                    };
                    dataEgressFees: {
                        value: number;
                        poweredBy: string;
                    };
                    spendOverTime: {
                        date: Date;
                        limit: number;
                        spend: number;
                    }[];
                    usageBreakdown: {
                        date: Date;
                        totalCost: number;
                        conversationId: string;
                        agentsInvolved: string[];
                        tokens: number;
                    }[];
                }, {
                    totalSpend: {
                        value: number;
                        period: string;
                        change: number;
                    };
                    resolvedConversations: {
                        value: number;
                        change: number;
                    };
                    avgCostPerResolution: {
                        value: number;
                        change: number;
                        changeType: "increase" | "decrease";
                    };
                    dataEgressFees: {
                        value: number;
                        poweredBy: string;
                    };
                    spendOverTime: {
                        date: Date;
                        limit: number;
                        spend: number;
                    }[];
                    usageBreakdown: {
                        date: Date;
                        totalCost: number;
                        conversationId: string;
                        agentsInvolved: string[];
                        tokens: number;
                    }[];
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
    };
    audit: {
        listAuditLogs: {
            query: zod.ZodObject<{
                page: zod.ZodDefault<zod.ZodNumber>;
                limit: zod.ZodDefault<zod.ZodNumber>;
            } & {
                action: zod.ZodOptional<zod.ZodString>;
                actorType: zod.ZodOptional<zod.ZodEnum<["user", "agent", "system"]>>;
                actorId: zod.ZodOptional<zod.ZodString>;
                targetType: zod.ZodOptional<zod.ZodString>;
                targetId: zod.ZodOptional<zod.ZodString>;
                fromDate: zod.ZodOptional<zod.ZodDate>;
                toDate: zod.ZodOptional<zod.ZodDate>;
            }, "strip", zod.ZodTypeAny, {
                page: number;
                limit: number;
                fromDate?: Date | undefined;
                toDate?: Date | undefined;
                action?: string | undefined;
                actorType?: "user" | "agent" | "system" | undefined;
                actorId?: string | undefined;
                targetType?: string | undefined;
                targetId?: string | undefined;
            }, {
                page?: number | undefined;
                limit?: number | undefined;
                fromDate?: Date | undefined;
                toDate?: Date | undefined;
                action?: string | undefined;
                actorType?: "user" | "agent" | "system" | undefined;
                actorId?: string | undefined;
                targetType?: string | undefined;
                targetId?: string | undefined;
            }>;
            summary: "List audit logs with XAI trail";
            method: "GET";
            path: "/api/v1/audit/logs";
            responses: {
                200: zod.ZodObject<{
                    logs: zod.ZodArray<zod.ZodObject<{
                        id: zod.ZodString;
                        action: zod.ZodString;
                        actorType: zod.ZodEnum<["user", "agent", "system"]>;
                        actorId: zod.ZodNullable<zod.ZodString>;
                        targetType: zod.ZodNullable<zod.ZodString>;
                        targetId: zod.ZodNullable<zod.ZodString>;
                        details: zod.ZodRecord<zod.ZodString, zod.ZodUnknown>;
                        decision: zod.ZodNullable<zod.ZodString>;
                        reasoning: zod.ZodNullable<zod.ZodString>;
                        rbacCheck: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                        ipAddress: zod.ZodNullable<zod.ZodString>;
                        userAgent: zod.ZodNullable<zod.ZodString>;
                        timestamp: zod.ZodDate;
                        organizationId: zod.ZodString;
                        userId: zod.ZodNullable<zod.ZodString>;
                        agentActionId: zod.ZodNullable<zod.ZodString>;
                    }, "strip", zod.ZodTypeAny, {
                        id: string;
                        organizationId: string;
                        details: Record<string, unknown>;
                        userId: string | null;
                        action: string;
                        reasoning: string | null;
                        actorType: "user" | "agent" | "system";
                        actorId: string | null;
                        targetType: string | null;
                        targetId: string | null;
                        decision: string | null;
                        rbacCheck: Record<string, unknown> | null;
                        ipAddress: string | null;
                        userAgent: string | null;
                        timestamp: Date;
                        agentActionId: string | null;
                    }, {
                        id: string;
                        organizationId: string;
                        details: Record<string, unknown>;
                        userId: string | null;
                        action: string;
                        reasoning: string | null;
                        actorType: "user" | "agent" | "system";
                        actorId: string | null;
                        targetType: string | null;
                        targetId: string | null;
                        decision: string | null;
                        rbacCheck: Record<string, unknown> | null;
                        ipAddress: string | null;
                        userAgent: string | null;
                        timestamp: Date;
                        agentActionId: string | null;
                    }>, "many">;
                    pagination: zod.ZodObject<{
                        page: zod.ZodNumber;
                        limit: zod.ZodNumber;
                        total: zod.ZodNumber;
                        totalPages: zod.ZodNumber;
                    }, "strip", zod.ZodTypeAny, {
                        page: number;
                        limit: number;
                        total: number;
                        totalPages: number;
                    }, {
                        page: number;
                        limit: number;
                        total: number;
                        totalPages: number;
                    }>;
                }, "strip", zod.ZodTypeAny, {
                    pagination: {
                        page: number;
                        limit: number;
                        total: number;
                        totalPages: number;
                    };
                    logs: {
                        id: string;
                        organizationId: string;
                        details: Record<string, unknown>;
                        userId: string | null;
                        action: string;
                        reasoning: string | null;
                        actorType: "user" | "agent" | "system";
                        actorId: string | null;
                        targetType: string | null;
                        targetId: string | null;
                        decision: string | null;
                        rbacCheck: Record<string, unknown> | null;
                        ipAddress: string | null;
                        userAgent: string | null;
                        timestamp: Date;
                        agentActionId: string | null;
                    }[];
                }, {
                    pagination: {
                        page: number;
                        limit: number;
                        total: number;
                        totalPages: number;
                    };
                    logs: {
                        id: string;
                        organizationId: string;
                        details: Record<string, unknown>;
                        userId: string | null;
                        action: string;
                        reasoning: string | null;
                        actorType: "user" | "agent" | "system";
                        actorId: string | null;
                        targetType: string | null;
                        targetId: string | null;
                        decision: string | null;
                        rbacCheck: Record<string, unknown> | null;
                        ipAddress: string | null;
                        userAgent: string | null;
                        timestamp: Date;
                        agentActionId: string | null;
                    }[];
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        getAuditLog: {
            pathParams: zod.ZodObject<{
                id: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                id: string;
            }, {
                id: string;
            }>;
            summary: "Get detailed audit log entry";
            method: "GET";
            path: "/api/v1/audit/logs/:id";
            responses: {
                200: zod.ZodObject<{
                    id: zod.ZodString;
                    action: zod.ZodString;
                    actorType: zod.ZodEnum<["user", "agent", "system"]>;
                    actorId: zod.ZodNullable<zod.ZodString>;
                    targetType: zod.ZodNullable<zod.ZodString>;
                    targetId: zod.ZodNullable<zod.ZodString>;
                    details: zod.ZodRecord<zod.ZodString, zod.ZodUnknown>;
                    decision: zod.ZodNullable<zod.ZodString>;
                    reasoning: zod.ZodNullable<zod.ZodString>;
                    rbacCheck: zod.ZodNullable<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                    ipAddress: zod.ZodNullable<zod.ZodString>;
                    userAgent: zod.ZodNullable<zod.ZodString>;
                    timestamp: zod.ZodDate;
                    organizationId: zod.ZodString;
                    userId: zod.ZodNullable<zod.ZodString>;
                    agentActionId: zod.ZodNullable<zod.ZodString>;
                }, "strip", zod.ZodTypeAny, {
                    id: string;
                    organizationId: string;
                    details: Record<string, unknown>;
                    userId: string | null;
                    action: string;
                    reasoning: string | null;
                    actorType: "user" | "agent" | "system";
                    actorId: string | null;
                    targetType: string | null;
                    targetId: string | null;
                    decision: string | null;
                    rbacCheck: Record<string, unknown> | null;
                    ipAddress: string | null;
                    userAgent: string | null;
                    timestamp: Date;
                    agentActionId: string | null;
                }, {
                    id: string;
                    organizationId: string;
                    details: Record<string, unknown>;
                    userId: string | null;
                    action: string;
                    reasoning: string | null;
                    actorType: "user" | "agent" | "system";
                    actorId: string | null;
                    targetType: string | null;
                    targetId: string | null;
                    decision: string | null;
                    rbacCheck: Record<string, unknown> | null;
                    ipAddress: string | null;
                    userAgent: string | null;
                    timestamp: Date;
                    agentActionId: string | null;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        checkPermission: {
            summary: "Check RBAC permission for current user";
            method: "POST";
            body: zod.ZodObject<{
                resource: zod.ZodString;
                action: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                action: string;
                resource: string;
            }, {
                action: string;
                resource: string;
            }>;
            path: "/api/v1/audit/rbac/check";
            responses: {
                200: zod.ZodObject<{
                    resource: zod.ZodString;
                    action: zod.ZodString;
                    allowed: zod.ZodBoolean;
                    reason: zod.ZodOptional<zod.ZodString>;
                }, "strip", zod.ZodTypeAny, {
                    action: string;
                    resource: string;
                    allowed: boolean;
                    reason?: string | undefined;
                }, {
                    action: string;
                    resource: string;
                    allowed: boolean;
                    reason?: string | undefined;
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        exportAuditLog: {
            summary: "Export audit logs to JSON or CSV";
            method: "POST";
            body: zod.ZodObject<{
                format: zod.ZodEnum<["json", "csv"]>;
                filters: zod.ZodOptional<zod.ZodObject<{
                    action: zod.ZodOptional<zod.ZodString>;
                    actorType: zod.ZodOptional<zod.ZodEnum<["user", "agent", "system"]>>;
                    actorId: zod.ZodOptional<zod.ZodString>;
                    targetType: zod.ZodOptional<zod.ZodString>;
                    targetId: zod.ZodOptional<zod.ZodString>;
                    fromDate: zod.ZodOptional<zod.ZodDate>;
                    toDate: zod.ZodOptional<zod.ZodDate>;
                }, "strip", zod.ZodTypeAny, {
                    fromDate?: Date | undefined;
                    toDate?: Date | undefined;
                    action?: string | undefined;
                    actorType?: "user" | "agent" | "system" | undefined;
                    actorId?: string | undefined;
                    targetType?: string | undefined;
                    targetId?: string | undefined;
                }, {
                    fromDate?: Date | undefined;
                    toDate?: Date | undefined;
                    action?: string | undefined;
                    actorType?: "user" | "agent" | "system" | undefined;
                    actorId?: string | undefined;
                    targetType?: string | undefined;
                    targetId?: string | undefined;
                }>>;
            }, "strip", zod.ZodTypeAny, {
                format: "json" | "csv";
                filters?: {
                    fromDate?: Date | undefined;
                    toDate?: Date | undefined;
                    action?: string | undefined;
                    actorType?: "user" | "agent" | "system" | undefined;
                    actorId?: string | undefined;
                    targetType?: string | undefined;
                    targetId?: string | undefined;
                } | undefined;
            }, {
                format: "json" | "csv";
                filters?: {
                    fromDate?: Date | undefined;
                    toDate?: Date | undefined;
                    action?: string | undefined;
                    actorType?: "user" | "agent" | "system" | undefined;
                    actorId?: string | undefined;
                    targetType?: string | undefined;
                    targetId?: string | undefined;
                } | undefined;
            }>;
            path: "/api/v1/audit/logs/export";
            responses: {
                200: zod.ZodObject<{
                    downloadUrl: zod.ZodString;
                    expiresAt: zod.ZodDate;
                }, "strip", zod.ZodTypeAny, {
                    expiresAt: Date;
                    downloadUrl: string;
                }, {
                    expiresAt: Date;
                    downloadUrl: string;
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
    };
    integrations: {
        listIntegrations: {
            summary: "List all integrations";
            method: "GET";
            path: "/api/v1/integrations";
            responses: {
                200: zod.ZodObject<{
                    integrations: zod.ZodArray<zod.ZodObject<{
                        id: zod.ZodString;
                        type: zod.ZodEnum<["salesforce", "slack", "zendesk"]>;
                        name: zod.ZodString;
                        status: zod.ZodEnum<["connected", "disconnected", "error"]>;
                        lastSyncAt: zod.ZodNullable<zod.ZodDate>;
                        syncStatus: zod.ZodNullable<zod.ZodEnum<["success", "failed", "in_progress"]>>;
                        syncError: zod.ZodNullable<zod.ZodString>;
                        organizationId: zod.ZodString;
                    } & {
                        createdAt: zod.ZodDate;
                        updatedAt: zod.ZodDate;
                    }, "strip", zod.ZodTypeAny, {
                        type: "slack" | "salesforce" | "zendesk";
                        status: "error" | "connected" | "disconnected";
                        id: string;
                        name: string;
                        organizationId: string;
                        createdAt: Date;
                        updatedAt: Date;
                        lastSyncAt: Date | null;
                        syncStatus: "success" | "in_progress" | "failed" | null;
                        syncError: string | null;
                    }, {
                        type: "slack" | "salesforce" | "zendesk";
                        status: "error" | "connected" | "disconnected";
                        id: string;
                        name: string;
                        organizationId: string;
                        createdAt: Date;
                        updatedAt: Date;
                        lastSyncAt: Date | null;
                        syncStatus: "success" | "in_progress" | "failed" | null;
                        syncError: string | null;
                    }>, "many">;
                }, "strip", zod.ZodTypeAny, {
                    integrations: {
                        type: "slack" | "salesforce" | "zendesk";
                        status: "error" | "connected" | "disconnected";
                        id: string;
                        name: string;
                        organizationId: string;
                        createdAt: Date;
                        updatedAt: Date;
                        lastSyncAt: Date | null;
                        syncStatus: "success" | "in_progress" | "failed" | null;
                        syncError: string | null;
                    }[];
                }, {
                    integrations: {
                        type: "slack" | "salesforce" | "zendesk";
                        status: "error" | "connected" | "disconnected";
                        id: string;
                        name: string;
                        organizationId: string;
                        createdAt: Date;
                        updatedAt: Date;
                        lastSyncAt: Date | null;
                        syncStatus: "success" | "in_progress" | "failed" | null;
                        syncError: string | null;
                    }[];
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        getIntegration: {
            pathParams: zod.ZodObject<{
                id: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                id: string;
            }, {
                id: string;
            }>;
            summary: "Get integration by ID";
            method: "GET";
            path: "/api/v1/integrations/:id";
            responses: {
                200: zod.ZodObject<{
                    id: zod.ZodString;
                    type: zod.ZodEnum<["salesforce", "slack", "zendesk"]>;
                    name: zod.ZodString;
                    status: zod.ZodEnum<["connected", "disconnected", "error"]>;
                    lastSyncAt: zod.ZodNullable<zod.ZodDate>;
                    syncStatus: zod.ZodNullable<zod.ZodEnum<["success", "failed", "in_progress"]>>;
                    syncError: zod.ZodNullable<zod.ZodString>;
                    organizationId: zod.ZodString;
                } & {
                    createdAt: zod.ZodDate;
                    updatedAt: zod.ZodDate;
                }, "strip", zod.ZodTypeAny, {
                    type: "slack" | "salesforce" | "zendesk";
                    status: "error" | "connected" | "disconnected";
                    id: string;
                    name: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    lastSyncAt: Date | null;
                    syncStatus: "success" | "in_progress" | "failed" | null;
                    syncError: string | null;
                }, {
                    type: "slack" | "salesforce" | "zendesk";
                    status: "error" | "connected" | "disconnected";
                    id: string;
                    name: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    lastSyncAt: Date | null;
                    syncStatus: "success" | "in_progress" | "failed" | null;
                    syncError: string | null;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        createIntegration: {
            summary: "Create a new integration";
            method: "POST";
            body: zod.ZodObject<{
                type: zod.ZodEnum<["salesforce", "slack", "zendesk"]>;
                name: zod.ZodString;
                config: zod.ZodRecord<zod.ZodString, zod.ZodUnknown>;
                credentials: zod.ZodRecord<zod.ZodString, zod.ZodUnknown>;
            }, "strip", zod.ZodTypeAny, {
                type: "slack" | "salesforce" | "zendesk";
                name: string;
                config: Record<string, unknown>;
                credentials: Record<string, unknown>;
            }, {
                type: "slack" | "salesforce" | "zendesk";
                name: string;
                config: Record<string, unknown>;
                credentials: Record<string, unknown>;
            }>;
            path: "/api/v1/integrations";
            responses: {
                201: zod.ZodObject<{
                    id: zod.ZodString;
                    type: zod.ZodEnum<["salesforce", "slack", "zendesk"]>;
                    name: zod.ZodString;
                    status: zod.ZodEnum<["connected", "disconnected", "error"]>;
                    lastSyncAt: zod.ZodNullable<zod.ZodDate>;
                    syncStatus: zod.ZodNullable<zod.ZodEnum<["success", "failed", "in_progress"]>>;
                    syncError: zod.ZodNullable<zod.ZodString>;
                    organizationId: zod.ZodString;
                } & {
                    createdAt: zod.ZodDate;
                    updatedAt: zod.ZodDate;
                }, "strip", zod.ZodTypeAny, {
                    type: "slack" | "salesforce" | "zendesk";
                    status: "error" | "connected" | "disconnected";
                    id: string;
                    name: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    lastSyncAt: Date | null;
                    syncStatus: "success" | "in_progress" | "failed" | null;
                    syncError: string | null;
                }, {
                    type: "slack" | "salesforce" | "zendesk";
                    status: "error" | "connected" | "disconnected";
                    id: string;
                    name: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    lastSyncAt: Date | null;
                    syncStatus: "success" | "in_progress" | "failed" | null;
                    syncError: string | null;
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        updateIntegration: {
            pathParams: zod.ZodObject<{
                id: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                id: string;
            }, {
                id: string;
            }>;
            summary: "Update integration";
            method: "PATCH";
            body: zod.ZodObject<{
                name: zod.ZodOptional<zod.ZodString>;
                config: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                credentials: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
            }, "strip", zod.ZodTypeAny, {
                name?: string | undefined;
                config?: Record<string, unknown> | undefined;
                credentials?: Record<string, unknown> | undefined;
            }, {
                name?: string | undefined;
                config?: Record<string, unknown> | undefined;
                credentials?: Record<string, unknown> | undefined;
            }>;
            path: "/api/v1/integrations/:id";
            responses: {
                200: zod.ZodObject<{
                    id: zod.ZodString;
                    type: zod.ZodEnum<["salesforce", "slack", "zendesk"]>;
                    name: zod.ZodString;
                    status: zod.ZodEnum<["connected", "disconnected", "error"]>;
                    lastSyncAt: zod.ZodNullable<zod.ZodDate>;
                    syncStatus: zod.ZodNullable<zod.ZodEnum<["success", "failed", "in_progress"]>>;
                    syncError: zod.ZodNullable<zod.ZodString>;
                    organizationId: zod.ZodString;
                } & {
                    createdAt: zod.ZodDate;
                    updatedAt: zod.ZodDate;
                }, "strip", zod.ZodTypeAny, {
                    type: "slack" | "salesforce" | "zendesk";
                    status: "error" | "connected" | "disconnected";
                    id: string;
                    name: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    lastSyncAt: Date | null;
                    syncStatus: "success" | "in_progress" | "failed" | null;
                    syncError: string | null;
                }, {
                    type: "slack" | "salesforce" | "zendesk";
                    status: "error" | "connected" | "disconnected";
                    id: string;
                    name: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    lastSyncAt: Date | null;
                    syncStatus: "success" | "in_progress" | "failed" | null;
                    syncError: string | null;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        deleteIntegration: {
            pathParams: zod.ZodObject<{
                id: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                id: string;
            }, {
                id: string;
            }>;
            summary: "Delete integration";
            method: "DELETE";
            body: zod.ZodObject<{}, "strip", zod.ZodTypeAny, {}, {}>;
            path: "/api/v1/integrations/:id";
            responses: {
                200: zod.ZodObject<{
                    message: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                }, {
                    message: string;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        syncIntegration: {
            pathParams: zod.ZodObject<{
                id: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                id: string;
            }, {
                id: string;
            }>;
            summary: "Trigger manual sync for integration";
            method: "POST";
            body: zod.ZodObject<{}, "strip", zod.ZodTypeAny, {}, {}>;
            path: "/api/v1/integrations/:id/sync";
            responses: {
                200: zod.ZodObject<{
                    id: zod.ZodString;
                    type: zod.ZodEnum<["salesforce", "slack", "zendesk"]>;
                    name: zod.ZodString;
                    status: zod.ZodEnum<["connected", "disconnected", "error"]>;
                    lastSyncAt: zod.ZodNullable<zod.ZodDate>;
                    syncStatus: zod.ZodNullable<zod.ZodEnum<["success", "failed", "in_progress"]>>;
                    syncError: zod.ZodNullable<zod.ZodString>;
                    organizationId: zod.ZodString;
                } & {
                    createdAt: zod.ZodDate;
                    updatedAt: zod.ZodDate;
                }, "strip", zod.ZodTypeAny, {
                    type: "slack" | "salesforce" | "zendesk";
                    status: "error" | "connected" | "disconnected";
                    id: string;
                    name: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    lastSyncAt: Date | null;
                    syncStatus: "success" | "in_progress" | "failed" | null;
                    syncError: string | null;
                }, {
                    type: "slack" | "salesforce" | "zendesk";
                    status: "error" | "connected" | "disconnected";
                    id: string;
                    name: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    lastSyncAt: Date | null;
                    syncStatus: "success" | "in_progress" | "failed" | null;
                    syncError: string | null;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        listWebhooks: {
            summary: "List all webhooks";
            method: "GET";
            path: "/api/v1/webhooks";
            responses: {
                200: zod.ZodObject<{
                    webhooks: zod.ZodArray<zod.ZodObject<{
                        id: zod.ZodString;
                        url: zod.ZodString;
                        events: zod.ZodArray<zod.ZodString, "many">;
                        status: zod.ZodEnum<["active", "paused", "failed"]>;
                        lastTriggered: zod.ZodNullable<zod.ZodDate>;
                        failureCount: zod.ZodNumber;
                        organizationId: zod.ZodString;
                    } & {
                        createdAt: zod.ZodDate;
                        updatedAt: zod.ZodDate;
                    }, "strip", zod.ZodTypeAny, {
                        status: "active" | "failed" | "paused";
                        id: string;
                        organizationId: string;
                        createdAt: Date;
                        updatedAt: Date;
                        url: string;
                        events: string[];
                        lastTriggered: Date | null;
                        failureCount: number;
                    }, {
                        status: "active" | "failed" | "paused";
                        id: string;
                        organizationId: string;
                        createdAt: Date;
                        updatedAt: Date;
                        url: string;
                        events: string[];
                        lastTriggered: Date | null;
                        failureCount: number;
                    }>, "many">;
                }, "strip", zod.ZodTypeAny, {
                    webhooks: {
                        status: "active" | "failed" | "paused";
                        id: string;
                        organizationId: string;
                        createdAt: Date;
                        updatedAt: Date;
                        url: string;
                        events: string[];
                        lastTriggered: Date | null;
                        failureCount: number;
                    }[];
                }, {
                    webhooks: {
                        status: "active" | "failed" | "paused";
                        id: string;
                        organizationId: string;
                        createdAt: Date;
                        updatedAt: Date;
                        url: string;
                        events: string[];
                        lastTriggered: Date | null;
                        failureCount: number;
                    }[];
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        getWebhook: {
            pathParams: zod.ZodObject<{
                id: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                id: string;
            }, {
                id: string;
            }>;
            summary: "Get webhook by ID";
            method: "GET";
            path: "/api/v1/webhooks/:id";
            responses: {
                200: zod.ZodObject<{
                    id: zod.ZodString;
                    url: zod.ZodString;
                    events: zod.ZodArray<zod.ZodString, "many">;
                    status: zod.ZodEnum<["active", "paused", "failed"]>;
                    lastTriggered: zod.ZodNullable<zod.ZodDate>;
                    failureCount: zod.ZodNumber;
                    organizationId: zod.ZodString;
                } & {
                    createdAt: zod.ZodDate;
                    updatedAt: zod.ZodDate;
                }, "strip", zod.ZodTypeAny, {
                    status: "active" | "failed" | "paused";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    url: string;
                    events: string[];
                    lastTriggered: Date | null;
                    failureCount: number;
                }, {
                    status: "active" | "failed" | "paused";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    url: string;
                    events: string[];
                    lastTriggered: Date | null;
                    failureCount: number;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        createWebhook: {
            summary: "Create a new webhook";
            method: "POST";
            body: zod.ZodObject<{
                url: zod.ZodString;
                events: zod.ZodArray<zod.ZodEnum<["conversation.created", "conversation.resolved", "conversation.escalated", "escalation.created", "escalation.assigned", "escalation.resolved", "agent.action.completed"]>, "many">;
            }, "strip", zod.ZodTypeAny, {
                url: string;
                events: ("conversation.created" | "conversation.resolved" | "conversation.escalated" | "escalation.created" | "escalation.assigned" | "escalation.resolved" | "agent.action.completed")[];
            }, {
                url: string;
                events: ("conversation.created" | "conversation.resolved" | "conversation.escalated" | "escalation.created" | "escalation.assigned" | "escalation.resolved" | "agent.action.completed")[];
            }>;
            path: "/api/v1/webhooks";
            responses: {
                201: zod.ZodObject<{
                    id: zod.ZodString;
                    url: zod.ZodString;
                    events: zod.ZodArray<zod.ZodString, "many">;
                    status: zod.ZodEnum<["active", "paused", "failed"]>;
                    lastTriggered: zod.ZodNullable<zod.ZodDate>;
                    failureCount: zod.ZodNumber;
                    organizationId: zod.ZodString;
                } & {
                    createdAt: zod.ZodDate;
                    updatedAt: zod.ZodDate;
                }, "strip", zod.ZodTypeAny, {
                    status: "active" | "failed" | "paused";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    url: string;
                    events: string[];
                    lastTriggered: Date | null;
                    failureCount: number;
                }, {
                    status: "active" | "failed" | "paused";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    url: string;
                    events: string[];
                    lastTriggered: Date | null;
                    failureCount: number;
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        updateWebhook: {
            pathParams: zod.ZodObject<{
                id: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                id: string;
            }, {
                id: string;
            }>;
            summary: "Update webhook";
            method: "PATCH";
            body: zod.ZodObject<{
                url: zod.ZodOptional<zod.ZodString>;
                events: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
                status: zod.ZodOptional<zod.ZodEnum<["active", "paused", "failed"]>>;
            }, "strip", zod.ZodTypeAny, {
                status?: "active" | "failed" | "paused" | undefined;
                url?: string | undefined;
                events?: string[] | undefined;
            }, {
                status?: "active" | "failed" | "paused" | undefined;
                url?: string | undefined;
                events?: string[] | undefined;
            }>;
            path: "/api/v1/webhooks/:id";
            responses: {
                200: zod.ZodObject<{
                    id: zod.ZodString;
                    url: zod.ZodString;
                    events: zod.ZodArray<zod.ZodString, "many">;
                    status: zod.ZodEnum<["active", "paused", "failed"]>;
                    lastTriggered: zod.ZodNullable<zod.ZodDate>;
                    failureCount: zod.ZodNumber;
                    organizationId: zod.ZodString;
                } & {
                    createdAt: zod.ZodDate;
                    updatedAt: zod.ZodDate;
                }, "strip", zod.ZodTypeAny, {
                    status: "active" | "failed" | "paused";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    url: string;
                    events: string[];
                    lastTriggered: Date | null;
                    failureCount: number;
                }, {
                    status: "active" | "failed" | "paused";
                    id: string;
                    organizationId: string;
                    createdAt: Date;
                    updatedAt: Date;
                    url: string;
                    events: string[];
                    lastTriggered: Date | null;
                    failureCount: number;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        deleteWebhook: {
            pathParams: zod.ZodObject<{
                id: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                id: string;
            }, {
                id: string;
            }>;
            summary: "Delete webhook";
            method: "DELETE";
            body: zod.ZodObject<{}, "strip", zod.ZodTypeAny, {}, {}>;
            path: "/api/v1/webhooks/:id";
            responses: {
                200: zod.ZodObject<{
                    message: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                }, {
                    message: string;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        testWebhook: {
            pathParams: zod.ZodObject<{
                id: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                id: string;
            }, {
                id: string;
            }>;
            summary: "Test webhook with sample payload";
            method: "POST";
            body: zod.ZodObject<{
                event: zod.ZodString;
                payload: zod.ZodRecord<zod.ZodString, zod.ZodUnknown>;
            }, "strip", zod.ZodTypeAny, {
                event: string;
                payload: Record<string, unknown>;
            }, {
                event: string;
                payload: Record<string, unknown>;
            }>;
            path: "/api/v1/webhooks/:id/test";
            responses: {
                200: zod.ZodObject<{
                    message: zod.ZodString;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                }, {
                    message: string;
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                400: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
        getWebhookDeliveries: {
            pathParams: zod.ZodObject<{
                id: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                id: string;
            }, {
                id: string;
            }>;
            query: zod.ZodObject<{
                limit: zod.ZodDefault<zod.ZodNumber>;
            }, "strip", zod.ZodTypeAny, {
                limit: number;
            }, {
                limit?: number | undefined;
            }>;
            summary: "Get webhook delivery history";
            method: "GET";
            path: "/api/v1/webhooks/:id/deliveries";
            responses: {
                200: zod.ZodObject<{
                    deliveries: zod.ZodArray<zod.ZodObject<{
                        id: zod.ZodString;
                        event: zod.ZodString;
                        status: zod.ZodEnum<["pending", "delivered", "failed"]>;
                        statusCode: zod.ZodNullable<zod.ZodNumber>;
                        response: zod.ZodNullable<zod.ZodString>;
                        attempts: zod.ZodNumber;
                        nextRetry: zod.ZodNullable<zod.ZodDate>;
                        deliveredAt: zod.ZodNullable<zod.ZodDate>;
                        createdAt: zod.ZodDate;
                        webhookId: zod.ZodString;
                    }, "strip", zod.ZodTypeAny, {
                        status: "pending" | "failed" | "delivered";
                        id: string;
                        createdAt: Date;
                        statusCode: number | null;
                        event: string;
                        response: string | null;
                        attempts: number;
                        nextRetry: Date | null;
                        deliveredAt: Date | null;
                        webhookId: string;
                    }, {
                        status: "pending" | "failed" | "delivered";
                        id: string;
                        createdAt: Date;
                        statusCode: number | null;
                        event: string;
                        response: string | null;
                        attempts: number;
                        nextRetry: Date | null;
                        deliveredAt: Date | null;
                        webhookId: string;
                    }>, "many">;
                }, "strip", zod.ZodTypeAny, {
                    deliveries: {
                        status: "pending" | "failed" | "delivered";
                        id: string;
                        createdAt: Date;
                        statusCode: number | null;
                        event: string;
                        response: string | null;
                        attempts: number;
                        nextRetry: Date | null;
                        deliveredAt: Date | null;
                        webhookId: string;
                    }[];
                }, {
                    deliveries: {
                        status: "pending" | "failed" | "delivered";
                        id: string;
                        createdAt: Date;
                        statusCode: number | null;
                        event: string;
                        response: string | null;
                        attempts: number;
                        nextRetry: Date | null;
                        deliveredAt: Date | null;
                        webhookId: string;
                    }[];
                }>;
                404: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
                401: zod.ZodObject<{
                    message: zod.ZodString;
                    code: zod.ZodOptional<zod.ZodString>;
                    details: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
                }, "strip", zod.ZodTypeAny, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }, {
                    message: string;
                    code?: string | undefined;
                    details?: Record<string, unknown> | undefined;
                }>;
            };
        };
    };
};
type ApiContract = typeof apiContract;

export { type AgentAction, type AgentConfig, type AgentMetrics, type AgentStatus, type AgentType, type AgenticSystemStatus, type AnalyticsQuery, type ApiContract, type ApiKeyListItem, type ApiKeyResponse, type AssignEscalationInput, type AuditLog, type AuditLogFilters, type AuditLogListResponse, type ChangePasswordInput, type Conversation, type ConversationFilters, type ConversationListResponse, type ConversationMetrics, type ConversationWithMessages, type CreateApiKeyInput, type CreateConversationInput, type CreateEscalationInput, type CreateIntegrationInput, type CreateOrganizationInput, type CreateUserInput, type CreateWebhookInput, type DashboardMetrics, type EmergingIssue, type EmergingIssues, type ErrorResponse, type Escalation, type EscalationFilters, type EscalationListResponse, type ExportAuditLogInput, type FinOpsMetrics, type FrustrationDriver, type FrustrationDrivers, type Integration, type IntegrationType, type LoginInput, type LoginResponse, type Message, type Organization, type OrganizationSettings, type PaginationQuery, type PaginationResponse, type RBACPermission, type RefreshTokenInput, type RefreshTokenResponse, type RegisterInput, type RegisterResponse, type SendMessageInput, type SentimentOverTime, type SuccessResponse, type TestWebhookInput, type TimestampFields, type UpdateConversationInput, type UpdateEscalationInput, type UpdateIntegrationInput, type UpdateOrganizationInput, type UpdateUserInput, type UpdateWebhookInput, type User, type UserListResponse, type ValidationErrorResponse, type Webhook, type WebhookDelivery, agentActionSchema, agentConfigSchema, agentMetricsSchema, agentStatusSchema, agentTypeEnum, agenticSystemStatusSchema, agentsContract, analyticsContract, analyticsQuerySchema, apiContract, apiKeyListItemSchema, apiKeyResponseSchema, assignEscalationSchema, auditContract, auditLogFiltersSchema, auditLogListResponseSchema, auditLogSchema, authContract, changePasswordSchema, conversationFiltersSchema, conversationListResponseSchema, conversationMetricsSchema, conversationSchema, conversationWithMessagesSchema, conversationsContract, createApiKeySchema, createConversationSchema, createEscalationSchema, createIntegrationSchema, createOrganizationSchema, createUserSchema, createWebhookSchema, dashboardMetricsSchema, emergingIssueSchema, emergingIssuesSchema, errorResponseSchema, escalationFiltersSchema, escalationListResponseSchema, escalationSchema, escalationsContract, exportAuditLogSchema, finOpsMetricsSchema, frustrationDriverSchema, frustrationDriversSchema, integrationSchema, integrationTypeEnum, integrationsContract, knowledgeContract, loginResponseSchema, loginSchema, messageSchema, organizationSchema, organizationSettingsSchema, paginationQuerySchema, paginationResponseSchema, publicContract, rbacPermissionSchema, refreshTokenResponseSchema, refreshTokenSchema, registerResponseSchema, registerSchema, sendMessageSchema, sentimentOverTimeSchema, successResponseSchema, testWebhookSchema, timestampSchema, toolsContract, updateConversationSchema, updateEscalationSchema, updateIntegrationSchema, updateOrganizationSchema, updateUserSchema, updateWebhookSchema, userListResponseSchema, userSchema, uuidSchema, validationErrorResponseSchema, webhookDeliverySchema, webhookSchema };