import { z } from "zod";

export const CreateEmploidSchema = z.object({
    tenantId: z.string(),
    userId: z.string(),
    occupationId: z.string(),
    name: z.string(),
    alias: z.string().optional(),
    avatar: z.string().optional(),
    description: z.string().optional(),
    version: z.string().optional()
});

export const UpdateEmploidSchema = z.object({
    id: z.string(),
    name: z.string().optional(),
    alias: z.string().optional(),
    avatar: z.string().optional(),
    description: z.string().optional(),
    version: z.string().optional()
});

export const DeleteEmploidSchema = z.object({
    id: z.string(),
    tenantId: z.string()
});

export const ListEmploidsSchema = z.object({
    tenantId: z.string()
});

export const ListEmploidsPaginatedSchema = z.object({
    tenantId: z.string(),
    page: z.number().int().optional(),
    limit: z.number().int().optional(),
    search: z.string().optional(),
    status: z.array(z.string()).optional(),
    occupation: z.array(z.string()).optional(),
    createdBy: z.array(z.string()).optional().transform((arr) => {
        return arr?.map((item) => item.toLowerCase());
    }),
    sortBy: z.enum(['name', 'createdAt', 'updatedAt', 'relevance']).optional(),
    userId: z.string().optional(),
});

export const ListScopesSchema = z.object({
    tenantId: z.string().optional(),
    workerId: z.string().optional()
});

export const ListOccupationsSchema = z.object({

});

export const CreateOccupationSchema = z.object({
    tenantId: z.string(),
    id: z.string(),
    name: z.string(),
    description: z.string().optional()
});

export const UpdateOccupationSchema = z.object({
    id: z.string(),
    name: z.string(),
    description: z.string().optional(),
});

export const DeleteOccupationSchema = z.object({
    id: z.string()
});

export const PublishDomainSchema = z.object({
    domainId: z.string()
});

export const CreateDomainTopicSchema = z.object({
    id: z.string(),
    occupationId: z.string(),
    title: z.string(),
    prompt: z.string().optional(),
    instructions: z.array(z.string()).optional(),
});

export const UpdateDomainTopicSchema = z.object({
    id: z.string(),
    title: z.string(),
    prompt: z.string().optional(),
    instructions: z.array(z.string()).optional(),
});

export const DeleteDomainTopicSchema = z.object({
    id: z.string()
});

export const ListDomainTopicsSchema = z.object({
    tenantId: z.string(),
    occupationId: z.string()
});

export const ScopeTypeSchema = z.string().min(1);

export const CreateScopeSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
    parentScopeId: z.string().nullable().optional(),
    name: z.string().optional(),
    type: ScopeTypeSchema.optional(),
    isFolderType: z.boolean().optional(),
    description: z.string().optional(),
    content: z.any().optional()
});

export const GetScopeByTypeSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
    type: ScopeTypeSchema
});

export const UpdateScopeSchema = z.object({
    scopeId: z.string(),
    parentScopeId: z.string().nullable().optional(),
    name: z.string().optional(),
    description: z.string().optional(),
    isFolderType: z.boolean().optional(),
    content: z.any().optional(),
    markdownContent: z.string().nullable().optional(),
});

export const DeleteScopeSchema = z.object({
    scopeId: z.string()
});

export const WorkerBackgroundJobRuleSchema = z.object({
    mode: z.enum(["everyMinute", "everyHour", "everyDay", "everyWeek", "everyMonth", "cronExpression"]),
    interval: z.number().int().min(1).optional(),
    minute: z.number().int().min(0).max(59).optional(),
    hour: z.number().int().min(0).max(23).optional(),
    weekday: z.union([z.string(), z.number()]).optional(),
    dayOfMonth: z.number().int().min(1).max(31).optional(),
    cron: z.string().optional(),
});

export const WorkerBackgroundJobScheduleSchema = z.object({
    timezone: z.string().min(1),
    rule: WorkerBackgroundJobRuleSchema,
});

export const CreateWorkerBackgroundJobSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
    parentScopeId: z.string(),
    name: z.string().min(1).max(191),
    description: z.string().optional(),
    schedule: WorkerBackgroundJobScheduleSchema,
});

export const ListWorkerBackgroundJobsSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
});

export const UpdateWorkerBackgroundJobSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
    scopeId: z.string(),
    name: z.string().min(1).max(191).optional(),
    description: z.string().optional(),
    schedule: WorkerBackgroundJobScheduleSchema.optional(),
    enabled: z.boolean().optional(),
});

export const ListWorkerBackgroundJobExecutionsSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
    scopeId: z.string(),
    cursor: z.string().optional(),
    limit: z.number().int().min(1).max(100).optional(),
});

export const ClearWorkerBackgroundJobExecutionsSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
    scopeId: z.string(),
});

export const ExportKnowledgeTreeSchema = z.object({
    tenantId: z.string(),
    workerId: z.string()
});

export const ImportKnowledgeTreeSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
    importData: z.any()
});

export const CreateJobDefinitionSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
    scopeId: z.string(),
    name: z.string().max(191),
    description: z.string().optional(),
    category: z.enum(["technical", "administrative", "social"]).optional(),
    priority: z.enum(["high", "medium", "low"]).optional(),
    status: z.enum(["active", "inactive", "draft"]).optional(),
});

export const ListJobDefinitionSchema = z.object({
    tenantId: z.string(),
    workerId: z.string().optional(),
    scopeId: z.string().optional()
});

export const UpdateJobDefinitionSchema = z.object({
    id: z.string(),
    name: z.string().max(191).optional(),
    description: z.string().optional(),
    category: z.enum(["technical", "administrative", "social"]).optional(),
    priority: z.enum(["high", "medium", "low"]).optional(),
    status: z.enum(["active", "inactive", "draft"]).optional(),
    scopeId: z.string().nullable().optional(),
    content: z.any().optional(),
    markdownContent: z.string().nullable().optional(),
});

export const DeleteJobDefinitionSchema = z.object({
    id: z.string()
});

export const CreateCompetencySchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
    scopeId: z.string(),
    jobDefinitionId: z.string(),
    name: z.string(),
    description: z.string().optional(),
    inputs: z.array(z.string()).optional(),
});

export const ListCompetenciesSchema = z.object({
    tenantId: z.string(),
    workerId: z.string().optional(),
    scopeId: z.string().optional(),
    jobDefinitionId: z.string().optional()
});

export const UpdateCompetencySchema = z.object({
    id: z.string(),
    name: z.string(),
    description: z.string().optional(),
    inputs: z.array(z.string()).optional(),
});

export const DeleteCompetencySchema = z.object({
    id: z.string()
});

export const CreateAgentFlowSchema = z.object({
    tenantId: z.string(),
    name: z.string(),
    folderId: z.string().optional(),
    description: z.string().optional(),
    //flowData: z.object({}).passthrough()
});

export const UpdateAgentFlowSchema = z.object({
    id: z.string(),
    name: z.string().optional(),
    description: z.string().optional(),
    //flowData: z.object({}).passthrough()
});

export const DeleteAgentFlowSchema = z.object({
    id: z.string()
});

export const DuplicateAgentFlowSchema = z.object({
    id: z.string(),
    name: z.string(),
    description: z.string().nullable().optional(),
});

export const ChangeAgentflowProjectSchema = z.object({
    id: z.string(),
    projectId: z.string()
});



export const ListAgentFlowsSchema = z.object({
    tenantId: z.string()
});

const DataModelAgentFlowNameSchema = z.string().trim().min(1).max(255);
const DataModelAgentFlowDescriptionSchema = z.string().trim().max(180).nullable().optional();

export const CreateDataModelAgentFlowSchema = z.object({
    tenantId: z.string().min(1),
    dataModelId: z.string().min(1),
    name: DataModelAgentFlowNameSchema,
    description: DataModelAgentFlowDescriptionSchema,
});

export const ListDataModelAgentFlowsSchema = z.object({
    tenantId: z.string().min(1),
    dataModelId: z.string().min(1),
});

export const UpdateDataModelAgentFlowSchema = z.object({
    tenantId: z.string().min(1),
    dataModelId: z.string().min(1),
    agentFlowId: z.string().min(1),
    name: DataModelAgentFlowNameSchema,
    description: DataModelAgentFlowDescriptionSchema,
});

export const DeleteDataModelAgentFlowSchema = z.object({
    tenantId: z.string().min(1),
    dataModelId: z.string().min(1),
    agentFlowId: z.string().min(1),
});

export const CreateAgentFlowFolderSchema = z.object({
    tenantId: z.string(),
    name: z.string(),
    description: z.string().optional(),
    visibility: z.enum(["public", "private"]).optional(),
    ownerId: z.string().nullable().optional(),
});

export const UpdateAgentFlowFolderSchema = z.object({
    id: z.string(),
    name: z.string().optional(),
    description: z.string().optional(),
});

export const DeleteAgentFlowFolderSchema = z.object({
    tenantId: z.string(),
    name: z.string(),
});

export const ListAgentFlowFoldersSchema = z.object({
    tenantId: z.string(),
});

export const GetPrivateAgentFlowFolderSchema = z.object({
    tenantId: z.string(),
});

export const ListDriveItemsSchema = z.object({
    tenantId: z.string(),
    folderId: z.string().optional(),
});

export const ListDriveTreeSchema = z.object({
    tenantId: z.string(),
});

export const SearchDriveItemsSchema = z.object({
    tenantId: z.string(),
    query: z.string(),
});

export const CreateDriveFolderSchema = z.object({
    tenantId: z.string(),
    name: z.string(),
    parentId: z.string().optional(),
});

export const PrepareDriveUploadSchema = z.object({
    tenantId: z.string(),
    name: z.string(),
    parentId: z.string().optional(),
    mimeType: z.string().optional(),
});

export const RenameDriveItemSchema = z.object({
    itemId: z.string(),
    name: z.string(),
});

export const MoveDriveItemSchema = z.object({
    itemId: z.string(),
    targetParentId: z.string().optional(),
});

export const GetDriveDeleteImpactSchema = z.object({
    itemId: z.string(),
});

export const DeleteDriveItemSchema = z.object({
    itemId: z.string(),
});

export const ResolveDriveDownloadSchema = z.object({
    itemId: z.string(),
});

export const ListDriveRootsSchema = z.object({
    tenantId: z.string(),
});

export const EnsureDriveProviderCredentialSchema = z.object({
    tenantId: z.string(),
    provider: z.enum(["LOCAL", "GOOGLE_DRIVE", "DROPBOX"]),
});

export const ListDriveProviderFoldersSchema = z.object({
    tenantId: z.string(),
    provider: z.enum(["LOCAL", "GOOGLE_DRIVE", "DROPBOX"]),
    parentId: z.string().nullable().optional(),
    credentialId: z.string().nullable().optional(),
});

export const CreateDriveRootSchema = z.object({
    tenantId: z.string(),
    provider: z.enum(["LOCAL", "GOOGLE_DRIVE", "DROPBOX"]),
    name: z.string(),
    credentialId: z.string().nullable().optional(),
    remoteRootId: z.string().nullable().optional(),
    remoteRootPath: z.string().nullable().optional(),
});

export const DeleteDriveRootSchema = z.object({
    tenantId: z.string(),
    rootId: z.string(),
});

export const ListDriveRootItemsSchema = z.object({
    tenantId: z.string(),
    rootId: z.string(),
    folderId: z.string().optional(),
});

export const ListDriveRootTreeSchema = z.object({
    tenantId: z.string(),
    rootId: z.string(),
});

export const SearchDriveRootItemsSchema = z.object({
    tenantId: z.string(),
    rootId: z.string(),
    query: z.string(),
});

export const CreateDriveRootFolderSchema = z.object({
    tenantId: z.string(),
    rootId: z.string(),
    name: z.string(),
    parentId: z.string().optional(),
});

export const UploadDriveRootFilesSchema = z.object({
    tenantId: z.string(),
    rootId: z.string(),
    parentId: z.string().optional(),
    files: z.array(z.object({
        name: z.string(),
        base64: z.string(),
        mimeType: z.string().nullable().optional(),
    })),
});

export const RenameDriveRootItemSchema = z.object({
    tenantId: z.string(),
    rootId: z.string(),
    itemId: z.string(),
    name: z.string(),
});

export const MoveDriveRootItemSchema = z.object({
    tenantId: z.string(),
    rootId: z.string(),
    itemId: z.string(),
    targetParentId: z.string().optional(),
});

export const GetDriveRootDeleteImpactSchema = z.object({
    tenantId: z.string(),
    rootId: z.string(),
    itemId: z.string(),
});

export const DeleteDriveRootItemSchema = z.object({
    tenantId: z.string(),
    rootId: z.string(),
    itemId: z.string(),
});

export const ReadDriveRootFileContentSchema = z.object({
    tenantId: z.string(),
    rootId: z.string(),
    itemId: z.string(),
});

export const ReadDriveRootFileTextSchema = z.object({
    tenantId: z.string(),
    rootId: z.string(),
    itemId: z.string(),
});

export const ResolveDriveRootDownloadSchema = z.object({
    tenantId: z.string(),
    rootId: z.string(),
    itemId: z.string(),
});

export const CreateExtensionSchema = z.object({
    extensionId: z.string(),
    tenantId: z.string(),
    config: z.record(z.string(), z.unknown()).optional()
});

export const UpdateExtensionSchema = z.object({
    id: z.string(),
    config: z.record(z.string(), z.unknown()).optional(),
});

export const ListExtensionsSchema = z.object({
    tenantId: z.string(),
});

export const DeleteExtensionSchema = z.object({
    id: z.string()
});

export const CreateAssistantSchema = z.object({
    tenantId: z.string(),
    alias: z.string(),
    name: z.string(),
    description: z.string().optional(),
    prompt: z.string().optional(),
    config: z.object({
        mode: z.enum(["simple", "advanced"]),
    }).optional()
});

export const UpdateAssistantSchema = z.object({
    id: z.string(),
    alias: z.string().optional(),
    name: z.string().optional(),
    description: z.string().optional(),
    prompt: z.string().optional(),
    config: z.object({
        mode: z.enum(["simple", "advanced"]),
    }).optional()
});

export const DeleteAssistantSchema = z.object({
    id: z.string()
});


export const CreateAssistantInstructionSchema = z.object({
    tenantId: z.string(),
    assistantId: z.string(),
    title: z.string(),
    prompt: z.string(),
    instructions: z.array(z.string()).optional(),
});

export const ListAssistantInstructionsSchema = z.object({
    tenantId: z.string(),
    assistantId: z.string().optional(),
});

export const CreateAssistantConstraintSchema = z.object({
    tenantId: z.string(),
    assistantId: z.string(),
    title: z.string(),
    prompt: z.string(),
    constraints: z.array(z.string()).optional(),
});

export const ListAssistantConstraintsSchema = z.object({
    tenantId: z.string(),
    assistantId: z.string().optional(),
});


export const ListAssistantsSchema = z.object({
    tenantId: z.string()
});

export const CreateAssistantDatasourceSchema = z.object({
    tenantId: z.string(),
    assistantId: z.string(),
    name: z.string(),
    config: z.object({

    }).optional()
});



export const ListAssistantDatasourcesSchema = z.object({
    tenantId: z.string(),
    assistantId: z.string().optional(),
});

export const UpdateAssistantDatasourceSchema = z.object({
    id: z.string(),
    name: z.string().optional(),
    config: z.object({

    }).optional()
});

export const DeleteAssistantDatasourceSchema = z.object({
    id: z.string()
});

export const CreateAssistantSkillSchema = z.object({
    tenantId: z.string(),
    assistantId: z.string(),
    name: z.string(),
    config: z.object({

    }).optional()
});



export const ListAssistantSkillsSchema = z.object({
    tenantId: z.string(),
    assistantId: z.string().optional(),
});

export const UpdateAssistantSkillSchema = z.object({
    id: z.string(),
    name: z.string().optional(),
    config: z.object({

    }).optional()
});

export const DeleteAssistantSkillSchema = z.object({
    id: z.string()
});


export const CreateAssistantChannelSchema = z.object({
    tenantId: z.string(),
    assistantId: z.string(),
    name: z.string(),
    config: z.object({

    }).optional()
});

export const ListAssistantChannelsSchema = z.object({
    tenantId: z.string(),
    assistantId: z.string().optional(),
});

export const UpdateAssistantChannelSchema = z.object({
    id: z.string(),
    name: z.string().optional(),
    config: z.object({

    }).optional()
});

export const DeleteAssistantChannelSchema = z.object({
    id: z.string()
});

export const CreateWorkerSchema = z.object({
    tenantId: z.string(),
    emploidId: z.string().optional(),
    name: z.string(),
    description: z.string().optional(),
    avatar: z.string().optional(),
});

export const UpdateWorkerSchema = z.object({
    workerId: z.string(),
    name: z.string().optional(),
    description: z.string().optional(),
    emploidId: z.string().optional(),
    avatar: z.string().optional(),
    agentContainerImage: z.string().optional(),
    modelSettings: z.record(z.string(), z.unknown()).nullable().optional(),
});


export const DeleteWorkerSchema = z.object({
    workerId: z.string(),
});

export const ListWorkersSchema = z.object({
    tenantId: z.string()
});

export const CreateInputSchema = z.object({
    tenantId: z.string(),
    emploidId: z.string(),
    competencyId: z.string(),
    name: z.string(),
    description: z.string().optional(),
    type: z.enum(['string', 'number', 'boolean', 'object']).default('string'),
});

export const ListInputSchema = z.object({
    tenantId: z.string(),
    emploidId: z.string().optional(),
    competencyId: z.string().optional(),
});

export const UpdateInputSchema = z.object({
    id: z.string(),
    name: z.string().optional(),
    description: z.string().optional(),
    type: z.enum(['string', 'number', 'boolean', 'object']).optional(),
});

export const DeleteInputSchema = z.object({
    id: z.string(),
});

export const CreateTeamSchema = z.object({
    tenantId: z.string(),
    alias: z.string(),
    name: z.string(),
    description: z.string().optional(),
});

export const ListTeamsSchema = z.object({
    tenantId: z.string()
});

export const UpdateTeamSchema = z.object({
    teamId: z.string(),
    alias: z.string().optional(),
    name: z.string().optional(),
    description: z.string().optional(),
});

export const DeleteTeamSchema = z.object({
    teamId: z.string(),
});

export const SaveChatSchema = z.object({
    id: z.string().optional(),
    title: z.string(),
    userId: z.string(),
    visibility: z.enum(['private', 'public']),
});

export const DeleteChatByIdSchema = z.object({
    id: z.string(),
});

export const GetChatByIdSchema = z.object({
    id: z.string(),
});

export const GetChatsByUserIdSchema = z.object({
    userId: z.string(),
    limit: z.number(),
    startingAfter: z.string().nullable().optional(),
    endingBefore: z.string().nullable().optional(),
});

export const SaveMessagesSchema = z.object({
    messages: z.array(z.object())
});


export const GetMessagesByChatIdSchema = z.object({
    chatId: z.string(),
});

export const GetMessageByIdSchema = z.object({
    id: z.string(),
});

export const VoteMessageSchema = z.object({
    chatId: z.string(),
    messageId: z.string(),
    type: z.enum(['up', 'down']),
});

export const GetVotesByChatIdSchema = z.object({
    chatId: z.string(),
});

export const DeleteDocumentsByIdAfterTimestampSchema = z.object({
    id: z.string(),
    timestamp: z.date(),
});

export const SaveSuggestionsSchema = z.object({
    suggestions: z.array(z.object({}))
});

export const GetSuggestionsByDocumentIdSchema = z.object({
    id: z.string(),
});

export const DeleteMessagesByChatIdAfterTimestampSchema = z.object({
    chatId: z.string(),
    timestamp: z.date(),
});

export const UpdateChatVisiblityByIdSchema = z.object({
    id: z.string(),
    visibility: z.enum(['private', 'public']),
});

export const UpdateChatLastContextByIdSchema = z.object({
    id: z.string(),
    context: z.object({}),
});

export const GetMessageCountByUserIdSchema = z.object({
    userId: z.string(),
    differenceInHours: z.number(),
});

export const CreateStreamIdSchema = z.object({
    streamId: z.string(),
    chatId: z.string(),
});

export const GetStreamIdsByChatIdSchema = z.object({
    chatId: z.string(),
});

export const SaveDocumentSchema = z.object({
    id: z.string().optional(),
    title: z.string(),
    kind: z.enum(['text', 'code', 'image', 'sheet']),
    content: z.string(),
    userId: z.string(),
});

export const GetDocumentByIdSchema = z.object({
    id: z.string(),
});

export const GetDocumentsByIdSchema = z.object({
    id: z.string(),
});



export const CreateInstructionSchema = z.object({
    emploidId: z.string(),
    content: z.string(),
    type: z.enum(['USER', 'SYSTEM']),
    active: z.boolean(),
});

export const ListInstructionsSchema = z.object({
    type: z.string().optional(),
    searchText: z.string().optional(),
    active: z.boolean().optional(),
    emploidId: z.string().optional()
});

export const UpdateInstructionSchema = z.object({
    id: z.string(),
    type: z.enum(['USER', 'SYSTEM']).optional(),
    content: z.string().optional(),
    active: z.boolean().optional(),
});

export const DeleteInstructionSchema = z.object({
    id: z.string(),
});


export const CreateCommandSchema = z.object({
    tenantId: z.string(),
    name: z.string(),
    description: z.string().optional(),
    type: z.enum(['WORKER', 'ASSISTANT', 'TEAM', 'FLOW']).default('FLOW'),
    targetId: z.string(),
    targetType: z.string(),
    inputs: z.array(z.object({
        "label": z.string(),
        "name": z.string(),
        "type": z.enum(['string', 'number', 'boolean', 'object']).default('string'),
    })).optional(),
});

export const ListCommandsSchema = z.object({
    tenantId: z.string()
});

export const UpdateCommandSchema = z.object({
    id: z.string(),
    name: z.string().optional(),
    description: z.string().optional(),
    type: z.enum(['WORKER', 'ASSISTANT', 'TEAM', 'FLOW']).optional(),
    targetId: z.string().optional(),
    targetType: z.string().optional(),
});

export const DeleteCommandSchema = z.object({
    id: z.string(),
});



export const CreateConstraintSchema = z.object({
    emploidId: z.string(),
    content: z.string(),
    type: z.enum(['USER', 'SYSTEM']),
    active: z.boolean(),
});

export const ListConstraintsSchema = z.object({
    type: z.string().optional(),
    searchText: z.string().optional(),
    active: z.boolean().optional(),
    emploidId: z.string().optional()
});

export const UpdateConstraintSchema = z.object({
    id: z.string(),
    type: z.enum(['USER', 'SYSTEM']).optional(),
    content: z.string().optional(),
    active: z.boolean().optional(),
});

export const DeleteConstraintSchema = z.object({
    id: z.string(),
});

export const CreateTaskTemplateSchema = z.object({
    id: z.string().optional(),
    task: z.string(),
    description: z.string().optional(),
    tenantId: z.string(),
    emploidId: z.string().optional(),
    workerId: z.string().optional(),
});

export const UpdateTaskTemplateSchema = z.object({
    id: z.string(),
    task: z.string().optional(),
    description: z.string().optional(),
    tenantId: z.string().optional(),
    emploidId: z.string().optional(),
    workerId: z.string().optional(),
});

export const DeleteTaskTemplateSchema = z.object({
    id: z.string(),
});

export const ListTaskTemplatesSchema = z.object({
    emploidId: z.string().optional(),
    workerId: z.string().optional(),
});


//----------------------------Collections-------------------


/**
 * DataModel oluşturma
 */
export const CreateDataModelSchema = z.object({
    tenantId: z.string(),
    displayName: z.string(),
    name: z.string(), // data model name
    description: z.string().optional(),
});

/**
 * DataModel güncelleme (partial)
 */
export const UpdateDataModelSchema = z.object({
    tenantId: z.string(),
    dataModelId: z.string(),
    data: z.object({
        name: z.string().optional(),
        displayName: z.string().optional(),
        description: z.string().optional(),
    }).passthrough(),
});

/**
 * DataModel soft delete (archive)
 */
export const DeleteDataModelSchema = z.object({
    id: z.string(),
    deletedBy: z.string().optional(), // userId | system | emploid
});

/**
 * DataModel restore
 */
export const RestoreDataModelSchema = z.object({
    id: z.string(),
    restoredBy: z.string().optional(), // userId | system | emploid
});

/**
 * DataModel hard delete (geri dönülmez)
 */
export const ListDataModelsSchema = z.object({
    tenantId: z.string()
});

export const GetDataModelByIdSchema = z.object({
    tenantId: z.string(),
    dataModelId: z.string(),
});

export const ExportDataModelSchema = z.object({
    tenantId: z.string(),
    dataModelId: z.string(),
    includeData: z.boolean().optional(),
});

export const ImportDataModelSchema = z.object({
    tenantId: z.string(),
    exportData: z.object({}).catchall(z.any()),
    includeData: z.boolean().optional(),
    actor: z.string().optional(),
});

export const HardDeleteDataModelSchema = z.object({
    tenantId: z.string(),
    dataModelId: z.string(),

    confirmed: z.literal("YES"),
    deletedBy: z.string(), // system / admin
});


export const CreateCollectionSchema = z.object({
    tenantId: z.string(),
    dataModelId: z.string(),
    displayName: z.string(),
    name: z.string(),
    description: z.string().optional(),
});

export const UpdateCollectionSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    displayName: z.string().optional(),
    description: z.string().optional(),
    // Legacy callers used the same fields under a `data` envelope. The
    // backend accepts both shapes while direct fields remain canonical.
    data: z.object({
        displayName: z.string().optional(),
        description: z.string().optional(),
    }).optional(),
});

export const DeleteCollectionSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
});

export const ArchiveCollectionSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    reason: z.string(),
    actor: z.string(),
});

export const PurgeCollectionSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    actor: z.string(),
    confirm: z.literal("PURGE"),
});



export const ListCollectionsSchema = z.object({
    tenantId: z.string(),
    dataModelId: z.string().optional(),
});

export const GetCollectionByIdSchema = z.object({
    id: z.string(),
});

export const CreateRecordSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    data: z.object({}).catchall(z.any()),
});

export const UploadCollectionFileSchema = z.object({
    tenantId: z.string(),
    name: z.string(),
    base64: z.string(),
    mimeType: z.string().optional(),
    collectionId: z.string().optional(),
    itemId: z.string().optional(),
});

export const ResolveCollectionFileViewSchema = z.object({
    itemId: z.string(),
});

export const GetRecordByIdSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    recordId: z.string(),
});

export const ListRecordsSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),

    limit: z.number().optional(),
    offset: z.number().optional(),

    filter: z.object({}).catchall(z.any()).optional(),

    sort: z.object({}).catchall(z.string()).optional(),
});

export const UpdateRecordSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    recordId: z.string(),

    data: z.object({}).catchall(z.any()),
});

export const DeleteRecordSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    recordId: z.string(),
});

export const RestoreRecordSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    recordId: z.string(),
});

export const UpsertRecordSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),

    // varsa update, yoksa create
    recordId: z.string().optional(),

    data: z.object({}).catchall(z.any()),
});

export const BulkCreateRecordsSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),

    records: z.array(
        z.object({}).catchall(z.any())
    ),
});

export const EnsureAirtableImportCredentialSchema = z.object({
    tenantId: z.string(),
});

export const ListAirtableImportSourcesSchema = z.object({
    tenantId: z.string(),
});

export const PreviewAirtableImportSchema = z.object({
    tenantId: z.string(),
    baseId: z.string(),
    tableIds: z.array(z.string()).min(1),
});

export const RunAirtableImportSchema = z.object({
    tenantId: z.string(),
    baseId: z.string(),
    tables: z.array(
        z.object({
            tableId: z.string(),
            collectionName: z.string(),
            collectionDisplayName: z.string(),
            fields: z.array(
                z.object({
                    fieldId: z.string(),
                    type: z.string(),
                    displayName: z.string(),
                    name: z.string(),
                    required: z.boolean().optional(),
                    config: z.object({}).catchall(z.any()).optional(),
                    relationTargetTableId: z.string().optional(),
                    fallbackReason: z.string().optional(),
                })
            ).min(1),
        })
    ).min(1),
});

export const EnsureLinearImportCredentialSchema = z.object({
    tenantId: z.string(),
});

export const ListLinearImportSourcesSchema = z.object({
    tenantId: z.string(),
});

export const PreviewLinearImportSchema = z.object({
    tenantId: z.string(),
    entityTypes: z.array(
        z.enum([
            "issues",
            "projects",
            "cycles",
            "teams",
            "users",
            "labels",
            "issueStates",
            "comments",
            "attachments",
        ])
    ).min(1),
    teamIds: z.array(z.string()).optional(),
    projectIds: z.array(z.string()).optional(),
    cycleIds: z.array(z.string()).optional(),
});

export const RunLinearImportSchema = z.object({
    tenantId: z.string(),
    entityTypes: z.array(
        z.enum([
            "issues",
            "projects",
            "cycles",
            "teams",
            "users",
            "labels",
            "issueStates",
            "comments",
            "attachments",
        ])
    ).min(1),
    teamIds: z.array(z.string()).optional(),
    projectIds: z.array(z.string()).optional(),
    cycleIds: z.array(z.string()).optional(),
    collections: z.array(
        z.object({
            entityType: z.enum([
                "issues",
                "projects",
                "cycles",
                "teams",
                "users",
                "labels",
                "issueStates",
                "comments",
                "attachments",
            ]),
            collectionName: z.string(),
            collectionDisplayName: z.string(),
            fields: z.array(
                z.object({
                    fieldId: z.string(),
                    type: z.string(),
                    displayName: z.string(),
                    name: z.string(),
                    required: z.boolean().optional(),
                    config: z.object({}).catchall(z.any()).optional(),
                    relationTargetEntityType: z.string().optional(),
                    fallbackReason: z.string().optional(),
                })
            ).min(1),
        })
    ).min(1),
});

export const EnsureNotionImportCredentialSchema = z.object({
    tenantId: z.string(),
});

export const EnsureGmailImportCredentialSchema = z.object({
    tenantId: z.string(),
});

export const EnsureGithubImportCredentialSchema = z.object({
    tenantId: z.string(),
});

const CsvImportInvalidRowPolicySchema = z.enum(["reject", "skip-row", "set-null"]);

const CsvImportRowRepairSchema = z.object({
    rowIndex: z.number().int().nonnegative(),
    fieldId: z.string().min(1),
    value: z.any(),
});

const CsvImportFieldMappingSchema = z.object({
    fieldId: z.string().min(1),
    type: z.string(),
    displayName: z.string(),
    name: z.string(),
    required: z.boolean().optional(),
    config: z.object({}).catchall(z.any()).optional(),
    fallbackReason: z.string().optional(),
    mode: z.enum(["field", "skip", "relation"]).optional(),
    relation: z.object({
        targetCollectionId: z.string().min(1),
        matchFieldName: z.string().min(1),
        unmatchedPolicy: z.enum(["reject", "ignore", "create"]),
        cardinality: z.enum(["one", "many"]).optional(),
        inverseCardinality: z.enum(["one", "many"]).optional(),
        inverseDisplayName: z.string().optional(),
        separator: z.string().max(8).optional(),
    }).optional(),
});

export const PreviewCsvImportSchema = z.object({
    tenantId: z.string(),
    fileName: z.string(),
    headersEnabled: z.boolean().optional(),
    columns: z.array(
        z.object({
            fieldId: z.string(),
            name: z.string(),
            displayName: z.string(),
            index: z.number().int(),
        })
    ).min(1),
    rows: z.array(z.object({}).catchall(z.any())).max(1_000).optional(),
    fields: z.array(CsvImportFieldMappingSchema).min(1).optional(),
    rowRepairs: z.array(CsvImportRowRepairSchema).max(10_000).optional(),
    invalidRowPolicy: CsvImportInvalidRowPolicySchema.optional(),
});

export const ListGmailImportSourcesSchema = z.object({
    tenantId: z.string(),
});

export const ListGithubImportSourcesSchema = z.object({
    tenantId: z.string(),
});

export const PreviewGmailImportSchema = z.object({
    tenantId: z.string(),
    collections: z.array(z.enum(["email", "contact"])).min(1),
    startFrom: z.string().optional(),
    labelIds: z.array(z.string()).optional(),
    preserveOriginalFormatting: z.boolean().optional(),
});

export const PreviewGithubImportSchema = z.object({
    tenantId: z.string(),
    repositoryId: z.string(),
    collections: z.array(z.enum(["issues", "pullRequests"])).min(1),
});

export const RunCsvImportSchema = z.object({
    tenantId: z.string(),
    dataModelId: z.string().optional(),
    fileName: z.string(),
    headersEnabled: z.boolean().optional(),
    columns: z.array(
        z.object({
            fieldId: z.string(),
            name: z.string(),
            displayName: z.string(),
            index: z.number().int(),
        })
    ).min(1),
    rows: z.array(z.object({}).catchall(z.any())).max(1_000),
    collection: z.object({
        collectionKey: z.literal("rows"),
        collectionName: z.string(),
        collectionDisplayName: z.string(),
        fields: z.array(CsvImportFieldMappingSchema).min(1),
        invalidRowPolicy: CsvImportInvalidRowPolicySchema.optional(),
        rowRepairs: z.array(CsvImportRowRepairSchema).max(10_000).optional(),
    }),
});

export const RunGmailImportSchema = z.object({
    tenantId: z.string(),
    dataModelId: z.string().optional(),
    collections: z.array(z.enum(["email", "contact"])).min(1),
    startFrom: z.string().optional(),
    labelIds: z.array(z.string()).optional(),
    preserveOriginalFormatting: z.boolean().optional(),
    collectionPayloads: z.array(
        z.object({
            collectionKey: z.enum(["email", "contact"]),
            collectionName: z.string(),
            collectionDisplayName: z.string(),
            fields: z.array(
                z.object({
                    fieldId: z.string(),
                    type: z.string(),
                    displayName: z.string(),
                    name: z.string(),
                    required: z.boolean().optional(),
                    config: z.object({}).catchall(z.any()).optional(),
                    relationTargetCollectionKey: z.enum(["email", "contact"]).optional(),
                    fallbackReason: z.string().optional(),
                })
            ).min(1),
        })
    ).min(1),
});

export const RunGithubImportSchema = z.object({
    tenantId: z.string(),
    repositoryId: z.string(),
    collections: z.array(
        z.object({
            collectionKey: z.enum(["issues", "pullRequests"]),
            collectionName: z.string(),
            collectionDisplayName: z.string(),
            fields: z.array(
                z.object({
                    fieldId: z.string(),
                    type: z.string(),
                    displayName: z.string(),
                    name: z.string(),
                    required: z.boolean().optional(),
                    config: z.object({}).catchall(z.any()).optional(),
                    fallbackReason: z.string().optional(),
                })
            ).min(1),
        })
    ).min(1),
});

export const ListNotionImportSourcesSchema = z.object({
    tenantId: z.string(),
});

export const PreviewNotionImportSchema = z.object({
    tenantId: z.string(),
    sourceIds: z.array(z.string()).min(1),
});

export const RunNotionImportSchema = z.object({
    tenantId: z.string(),
    sourceIds: z.array(z.string()).min(1),
    sources: z.array(
        z.object({
            sourceId: z.string(),
            collectionName: z.string(),
            collectionDisplayName: z.string(),
            fields: z.array(
                z.object({
                    fieldId: z.string(),
                    type: z.string(),
                    displayName: z.string(),
                    name: z.string(),
                    required: z.boolean().optional(),
                    config: z.object({}).catchall(z.any()).optional(),
                    relationTargetSourceId: z.string().optional(),
                    fallbackReason: z.string().optional(),
                })
            ).min(1),
        })
    ).min(1),
});

export const EnsureTrelloImportCredentialSchema = z.object({
    tenantId: z.string(),
});

export const EnsureJiraImportCredentialSchema = z.object({
    tenantId: z.string(),
});

export const ListJiraImportSourcesSchema = z.object({
    tenantId: z.string(),
    siteId: z.string().optional(),
});

export const PreviewJiraImportSchema = z.object({
    tenantId: z.string(),
    siteId: z.string(),
    projectId: z.string(),
    includeComments: z.boolean().optional(),
    includeAttachments: z.boolean().optional(),
});

export const RunJiraImportSchema = z.object({
    tenantId: z.string(),
    siteId: z.string(),
    projectId: z.string(),
    includeComments: z.boolean().optional(),
    includeAttachments: z.boolean().optional(),
    collections: z.array(
        z.object({
            collectionKey: z.enum(["issues", "comments", "attachments"]),
            collectionName: z.string(),
            collectionDisplayName: z.string(),
            fields: z.array(
                z.object({
                    fieldId: z.string(),
                    type: z.string(),
                    displayName: z.string(),
                    name: z.string(),
                    required: z.boolean().optional(),
                    config: z.object({}).catchall(z.any()).optional(),
                    relationTargetCollectionKey: z.enum(["issues", "comments", "attachments"]).optional(),
                    fallbackReason: z.string().optional(),
                })
            ).min(1),
        })
    ).min(1),
});

export const ConnectTrelloImportCredentialSchema = z.object({
    tenantId: z.string(),
    token: z.string(),
});

export const ListTrelloImportSourcesSchema = z.object({
    tenantId: z.string(),
    boardId: z.string().optional(),
    includeArchivedLists: z.boolean().optional(),
});

export const PreviewTrelloImportSchema = z.object({
    tenantId: z.string(),
    boardId: z.string(),
    listIds: z.array(z.string()).min(1),
    includeArchivedLists: z.boolean().optional(),
    includeClosedCards: z.boolean().optional(),
});

export const RunTrelloImportSchema = z.object({
    tenantId: z.string(),
    boardId: z.string(),
    listIds: z.array(z.string()).min(1),
    includeArchivedLists: z.boolean().optional(),
    includeClosedCards: z.boolean().optional(),
    lists: z.array(
        z.object({
            listId: z.string(),
            collectionName: z.string(),
            collectionDisplayName: z.string(),
            fields: z.array(
                z.object({
                    fieldId: z.string(),
                    type: z.string(),
                    displayName: z.string(),
                    name: z.string(),
                    required: z.boolean().optional(),
                    config: z.object({}).catchall(z.any()).optional(),
                })
            ).min(1),
        })
    ).min(1),
});

const BulkUpdateRecordSchema = z.object({
    recordId: z.string(),
    data: z.object({}).catchall(z.any()),
});

const LegacyBulkUpdateRecordSchema = z.object({
    id: z.string().optional(),
    recordId: z.string().optional(),
    data: z.object({}).catchall(z.any()),
}).refine((item) => Boolean(item.id || item.recordId), {
    message: "Each bulk update item must include id or recordId",
});

const BulkUpdateRecordsBaseSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    actor: z.string().optional(),
});

export const BulkUpdateRecordsSchema = z.union([
    BulkUpdateRecordsBaseSchema.extend({
        records: z.array(BulkUpdateRecordSchema).min(1),
        items: z.array(LegacyBulkUpdateRecordSchema).optional(),
    }),
    BulkUpdateRecordsBaseSchema.extend({
        records: z.array(BulkUpdateRecordSchema).optional(),
        items: z.array(LegacyBulkUpdateRecordSchema).min(1),
    }),
]);

export const BulkDeleteRecordsSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),

    recordIds: z.array(z.string()),
});


export const DuplicateRecordSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    recordId: z.string(),

    // opsiyonel: kopya üzerinde override edilecek alanlar
    overrides: z.object({}).catchall(z.any()).optional(),
});

export const QueryRecordsSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),

    // where / filter
    filter: z.object({}).catchall(z.any()).optional(),

    // projection (hangi alanlar gelsin)
    fields: z.union([
        z.array(z.string()),
        z.object({}).catchall(z.any()),
    ]).optional(),

    // sorting
    sort: z.object({}).catchall(z.string()).optional(),

    // pagination
    limit: z.number().optional(),
    offset: z.number().optional(),

    // Compatibility with the original backend action, which expected the
    // complete query DSL in one parameter.
    query: z.object({
        where: z.object({}).catchall(z.any()).optional(),
        filter: z.object({}).catchall(z.any()).optional(),
        fields: z.union([
            z.array(z.string()),
            z.object({}).catchall(z.any()),
        ]).optional(),
        sort: z.object({}).catchall(z.string()).optional(),
        limit: z.number().optional(),
        offset: z.number().optional(),
    }).optional(),
});

const SearchRecordsBaseSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),

    // opsiyonel: hangi alanlarda aransın
    fields: z.array(z.string()).optional(),

    // opsiyonel ek filtreler
    filter: z.object({}).catchall(z.any()).optional(),

    // sorting
    sort: z.object({}).catchall(z.string()).optional(),

    // pagination
    limit: z.number().optional(),
    offset: z.number().optional(),
});

export const SearchRecordsSchema = z.union([
    SearchRecordsBaseSchema.extend({
        // Canonical public name.
        query: z.string().min(1),
        q: z.string().optional(),
    }),
    SearchRecordsBaseSchema.extend({
        // Compatibility with the original backend action and Agent Flow node.
        query: z.string().optional(),
        q: z.string().min(1),
    }),
]);

export const CountRecordsSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),

    // opsiyonel filtre
    filter: z.object({}).catchall(z.any()).optional(),
});

export const GroupRecordsSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),

    // hangi alan(lar)a göre gruplanacak
    by: z.array(z.string()),

    // opsiyonel filtre
    filter: z.object({}).catchall(z.any()).optional(),

    // aggregation tanımı (count, sum, avg vb.)
    aggregations: z.object({}).catchall(z.any()).optional(),

    // sorting
    sort: z.object({}).catchall(z.string()).optional(),

    // pagination
    limit: z.number().optional(),
    offset: z.number().optional(),
});

export const AggregateRecordsSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),

    // aggregation pipeline
    pipeline: z.array(
        z.object({}).catchall(z.any())
    ),

    // opsiyonel: pipeline öncesi filtre
    filter: z.object({}).catchall(z.any()).optional(),

    // opsiyonel: pagination (aggregation sonrası)
    limit: z.number().optional(),
    offset: z.number().optional(),
});

export const DistinctFieldValuesSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),

    // distinct alınacak alan
    field: z.string(),

    // opsiyonel filtre
    filter: z.object({}).catchall(z.any()).optional(),

    // opsiyonel limit (çok büyük setleri kırpmak için)
    limit: z.number().optional(),
});

export const CollectionDerivedConditionSchema = z.object({
    fieldId: z.string(),
    fieldName: z.string().optional(),
    operator: z.enum([
        "eq", "neq", "contains", "not-contains", "gt", "gte", "lt", "lte",
        "is-empty", "is-not-empty",
    ]),
    value: z.unknown().optional(),
});

export const CollectionFieldConfigSchema = z.object({
    relationFieldId: z.string().optional(),
    relationFieldName: z.string().optional(),
    relationId: z.string().optional(),
    targetCollectionId: z.string().optional(),
    targetFieldId: z.string().optional(),
    targetFieldName: z.string().optional(),
    resultMode: z.enum(["first", "list"]).optional(),
    operation: z.enum([
        "count", "count-values", "count-unique", "sum", "average", "min", "max",
    ]).optional(),
    condition: CollectionDerivedConditionSchema.optional(),
    maxItems: z.number().int().min(1).max(500).optional(),
    min: z.number().optional(),
    max: z.number().optional(),
    precision: z.number().int().min(0).max(4).optional(),
    mode: z.enum(["typed", "drawn", "both"]).optional(),
    source: z.enum(["organization", "users", "employees", "both"]).optional(),
    includeInactive: z.boolean().optional(),
}).catchall(z.any());

export const CollectionChecklistItemSchema = z.object({
    id: z.string().min(1).max(128),
    text: z.string().min(1).max(1000),
    checked: z.boolean(),
});

export const CollectionSignatureValueSchema = z.object({
    kind: z.enum(["typed", "drawn"]),
    value: z.string().min(1),
    signedAt: z.string().datetime(),
    signedBy: z.string().min(1),
});

/** Browser/import input. signedAt and signedBy are server-managed output fields. */
export const CollectionSignatureInputSchema = CollectionSignatureValueSchema.pick({
    kind: true,
    value: true,
});

export const CreateCollectionFieldSchema = z.object({
    tenantId: z.string(),
    dataModelId: z.string(),
    collectionId: z.string(),

    name: z.string(),        // field key
    displayName: z.string(),       // UI label
    type: z.string(),        // string | number | boolean | date | json | relation | ...
    required: z.boolean().optional(),

    // field-specific config (min, max, enum, format, relation, etc.)
    config: CollectionFieldConfigSchema.optional(),

    // opsiyonel sıralama
    order: z.number().optional(),
});

export const UpdateCollectionFieldSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    fieldId: z.string(),

    // güncellenebilir alanlar
    displayName: z.string().optional(),
    type: z.string().optional(),
    required: z.boolean().optional(),

    // field-specific config (min, max, enum, relation vb.)
    config: CollectionFieldConfigSchema.optional(),

    // opsiyonel sıralama
    order: z.number().optional(),
});

export const DeleteCollectionFieldSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    fieldId: z.string(),
});

export const ListCollectionAutomationRulesSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string().optional(),
    dataModelId: z.string().optional(),
});

const CollectionAutomationRuleTriggerConfigSchema = z.object({
    updatedFieldId: z.string().nullable().optional(),
    cron: z.string().max(191).nullable().optional(),
    timezone: z.string().max(64).nullable().optional(),
    maxRecords: z.number().int().min(1).max(100).optional(),
});

const CollectionAutomationRuleConditionSchema = z.object({
    id: z.string(),
    fieldId: z.string(),
    operator: z.enum(["is", "is-not", "contains", "is-empty", "is-not-empty"]),
    value: z.union([z.string(), z.array(z.string()), z.boolean(), z.null()]).optional(),
});

const CollectionAutomationRuleActionSchema: z.ZodType<Record<string, unknown>> = z.lazy(() => z.object({
    id: z.string().min(1),
    type: z.enum([
        "create", "update", "delete", "append-description", "script",
        "conditional-branch", "find-records", "for-each", "copy-record",
        "move-record", "webhook", "approval",
    ]).nullable(),
    fieldId: z.string().nullable().optional(),
    value: z.string().optional(),
    valueMode: z.enum(["literal", "formula"]).optional(),
    formula: z.string().optional(),
    template: z.string().optional(),
    script: z.string().optional(),
    condition: CollectionAutomationRuleConditionSchema.nullable().optional(),
    thenActions: z.array(CollectionAutomationRuleActionSchema).max(100).optional(),
    elseActions: z.array(CollectionAutomationRuleActionSchema).max(100).optional(),
    collectionId: z.string().nullable().optional(),
    filters: z.array(CollectionAutomationRuleConditionSchema).max(25).optional(),
    limit: z.number().int().min(1).max(100).optional(),
    resultKey: z.string().max(80).optional(),
    sourceKey: z.string().max(80).optional(),
    maxIterations: z.number().int().min(1).max(50).optional(),
    actions: z.array(CollectionAutomationRuleActionSchema).max(100).optional(),
    targetCollectionId: z.string().nullable().optional(),
    fieldMap: z.record(z.string(), z.string()).optional(),
    url: z.string().max(2048).optional(),
    method: z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]).optional(),
    headers: z.record(z.string(), z.string()).optional(),
    body: z.unknown().optional(),
    timeoutMs: z.number().int().min(1).max(10_000).optional(),
    approverIds: z.array(z.string()).max(25).optional(),
    approvalMessage: z.string().max(2_000).optional(),
}));

export const CreateCollectionAutomationRuleSchema = z.object({
    tenantId: z.string(),
    dataModelId: z.string(),
    collectionId: z.string(),
    name: z.string(),
    description: z.string().optional(),
    enabled: z.boolean().optional(),
    trigger: z.enum(["created", "updated", "linked", "unlinked", "schedule"]),
    triggerConfig: CollectionAutomationRuleTriggerConfigSchema.nullable().optional(),
    conditions: z.array(CollectionAutomationRuleConditionSchema).optional(),
    actions: z.array(CollectionAutomationRuleActionSchema).min(1).max(100),
});

export const UpdateCollectionAutomationRuleSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    ruleId: z.string(),
    name: z.string().optional(),
    description: z.string().optional(),
    enabled: z.boolean().optional(),
    trigger: z.enum(["created", "updated", "linked", "unlinked", "schedule"]).optional(),
    triggerConfig: CollectionAutomationRuleTriggerConfigSchema.nullable().optional(),
    conditions: z.array(CollectionAutomationRuleConditionSchema).optional(),
    actions: z.array(CollectionAutomationRuleActionSchema).min(1).max(100).optional(),
});

export const DeleteCollectionAutomationRuleSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    ruleId: z.string(),
});

export const ListCollectionAutomationExecutionsSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string().optional(),
    ruleId: z.string().optional(),
    status: z.enum(["queued", "running", "waiting_approval", "succeeded", "failed", "skipped", "cancelled"]).optional(),
    cursor: z.string().optional(),
    limit: z.number().int().min(1).max(100).optional(),
});

export const DecideCollectionAutomationApprovalSchema = z.object({
    tenantId: z.string(),
    approvalId: z.string(),
    decision: z.enum(["approved", "rejected"]),
    note: z.string().max(2_000).optional(),
});

export const ListCollectionViewsSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
});

export const CreateCollectionViewSchema = z.object({
    tenantId: z.string(),
    dataModelId: z.string(),
    collectionId: z.string(),
    name: z.string().trim().min(1).max(191),
    type: z.enum(["grid", "board", "calendar", "timeline", "tree", "gallery", "map", "document"]),
    config: z.object({}).catchall(z.any()),
    visibility: z.enum(["shared", "personal"]).optional(),
});

export const UpdateCollectionViewSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    viewId: z.string(),
    name: z.string().trim().min(1).max(191).optional(),
    type: z.enum(["grid", "board", "calendar", "timeline", "tree", "gallery", "map", "document"]).optional(),
    config: z.object({}).catchall(z.any()).optional(),
    visibility: z.enum(["shared", "personal"]).optional(),
});

export const DeleteCollectionViewSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    viewId: z.string(),
});

export const UpsertCollectionViewPreferenceSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    viewId: z.string(),
    columns: z.array(z.object({
        fieldName: z.string().trim().min(1).max(191),
        visible: z.boolean(),
        width: z.number().positive().max(2_000).optional(),
    })).max(500),
});

export const DeleteCollectionViewPreferenceSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    viewId: z.string(),
});

export const ListCollectionButtonsSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string().optional(),
    dataModelId: z.string().optional(),
});

export const CreateCollectionButtonSchema = z.object({
    tenantId: z.string(),
    dataModelId: z.string(),
    collectionId: z.string(),
    name: z.string(),
    description: z.string().optional(),
    enabled: z.boolean().optional(),
    actions: z.array(z.object({}).catchall(z.any())),
});

export const UpdateCollectionButtonSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    buttonId: z.string(),
    name: z.string().optional(),
    description: z.string().optional(),
    enabled: z.boolean().optional(),
    actions: z.array(z.object({}).catchall(z.any())).optional(),
});

export const DeleteCollectionButtonSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    buttonId: z.string(),
});

export const ExecuteCollectionButtonSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    buttonId: z.string(),
    recordId: z.string(),
});

export const ExecuteCollectionAiFieldSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    fieldId: z.string(),
    recordId: z.string(),
});

export const ListCollectionRelationsSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
});

export const CreateCollectionRelationSchema = z.object({
    tenantId: z.string(),
    dataModelId: z.string(),
    collectionId: z.string(),
    targetCollectionId: z.string(),
    displayName: z.string(),
    description: z.string().optional(),
    cardinality: z.enum(["one", "many"]).optional(),
    inverseCardinality: z.enum(["one", "many"]).optional(),
    inverseDisplayName: z.string().optional(),
});

export const UpdateCollectionRelationSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    fieldId: z.string(),
    displayName: z.string().optional(),
    description: z.string().optional(),
    cardinality: z.enum(["one", "many"]).optional(),
    inverseCardinality: z.enum(["one", "many"]).optional(),
    targetDisplayName: z.string().optional(),
});

export const DeleteCollectionRelationSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    fieldId: z.string(),
    actor: z.string().optional(),
});

export const ListRelationCandidatesSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    fieldId: z.string(),
    query: z.string().optional(),
    limit: z.number().optional(),
});

export const GetRecordRelationsSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    recordId: z.string(),
});

const ReorderCollectionFieldsBaseSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
});

export const ReorderCollectionFieldsSchema = z.union([
    ReorderCollectionFieldsBaseSchema.extend({
        // Canonical shape: explicit field/order pairs.
        fields: z.array(
        z.object({
            fieldId: z.string(),
            order: z.number(),
        })
        ).min(1),
        fieldIds: z.array(z.string()).optional(),
    }),
    ReorderCollectionFieldsBaseSchema.extend({
        fields: z.array(
            z.object({
                fieldId: z.string(),
                order: z.number(),
            })
        ).optional(),
        // Compatibility with the original backend action.
        fieldIds: z.array(z.string()).min(1),
    }),
]);

export const GetCollectionSchemaSchema = z.object({
    tenantId: z.string(),
    dataModelId: z.string(),
    collectionId: z.string(),
});


export const ValidateRecordSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),

    // create / update öncesi doğrulanacak veri
    data: z.object({}).catchall(z.any()),

    // opsiyonel: update senaryosu için
    recordId: z.string().optional(),
});

export const PreviewValidationErrorsSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),

    // doğrulanacak veri (partial olabilir)
    data: z.object({}).catchall(z.any()),

    // opsiyonel: update senaryosu için
    recordId: z.string().optional(),
});

export const CheckRecordPermissionSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    recordId: z.string(),

    // yapılmak istenen işlem
    action: z.string(), // read | update | delete | restore | duplicate | custom
});

export const CollectionAccessPolicyScopeTypeSchema = z.enum(["app", "list", "field"]);
export const CollectionAccessPolicySubjectTypeSchema = z.enum(["user", "role", "team", "service"]);
export const CollectionAccessPolicyEffectSchema = z.enum(["allow", "deny"]);
export const CollectionAccessPolicyActionSchema = z.enum(["read", "create", "update", "delete", "comment", "assign"]);
export const CollectionAccessPolicyRowOperatorSchema = z.enum(["me", "user", "team", "linked-record"]);

export const CollectionAccessPolicyRowFilterSchema = z.object({
    match: z.enum(["all", "any"]),
    conditions: z.array(z.object({
        fieldId: z.string().min(1),
        operator: CollectionAccessPolicyRowOperatorSchema,
        value: z.string().optional(),
    })).min(1).max(20),
}).superRefine((filter, context) => {
    filter.conditions.forEach((condition, index) => {
        if (
            (condition.operator === "user"
                || condition.operator === "team"
                || condition.operator === "linked-record")
            && !condition.value?.trim()
        ) {
            context.addIssue({
                code: z.ZodIssueCode.custom,
                path: ["conditions", index, "value"],
                message: `${condition.operator} filters require a value`,
            });
        }
    });
});

export const ListCollectionAccessPoliciesSchema = z.object({
    tenantId: z.string().min(1),
    dataModelId: z.string().optional(),
    collectionId: z.string().optional(),
});

const CollectionAccessPolicyWriteSchema = z.object({
    tenantId: z.string().min(1),
    dataModelId: z.string().min(1),
    policyId: z.string().optional(),
    name: z.string().trim().min(1).max(160),
    scopeType: CollectionAccessPolicyScopeTypeSchema,
    collectionId: z.string().optional(),
    fieldId: z.string().optional(),
    subjectType: CollectionAccessPolicySubjectTypeSchema,
    subjectId: z.string().trim().min(1).max(255),
    effect: CollectionAccessPolicyEffectSchema,
    actions: z.array(CollectionAccessPolicyActionSchema).min(1).max(6),
    rowFilter: CollectionAccessPolicyRowFilterSchema.nullable().optional(),
    enabled: z.boolean().optional(),
});

function validateCollectionAccessPolicyShape(
    policy: {
        scopeType: z.infer<typeof CollectionAccessPolicyScopeTypeSchema>;
        collectionId?: string | undefined;
        fieldId?: string | undefined;
        actions: Array<z.infer<typeof CollectionAccessPolicyActionSchema>>;
        rowFilter?: z.infer<typeof CollectionAccessPolicyRowFilterSchema> | null | undefined;
    },
    context: z.RefinementCtx
) {
    if (policy.scopeType === "app") {
        if (policy.collectionId) {
            context.addIssue({ code: z.ZodIssueCode.custom, path: ["collectionId"], message: "App policies cannot target a collection" });
        }
        if (policy.fieldId) {
            context.addIssue({ code: z.ZodIssueCode.custom, path: ["fieldId"], message: "App policies cannot target a field" });
        }
    } else if (!policy.collectionId) {
        context.addIssue({ code: z.ZodIssueCode.custom, path: ["collectionId"], message: "List and field policies require a collection" });
    }

    if (policy.scopeType === "field") {
        if (!policy.fieldId) {
            context.addIssue({ code: z.ZodIssueCode.custom, path: ["fieldId"], message: "Field policies require a field" });
        }
        if (policy.actions.some((action) => action !== "read" && action !== "update")) {
            context.addIssue({ code: z.ZodIssueCode.custom, path: ["actions"], message: "Field policies only support read and update" });
        }
    } else if (policy.fieldId) {
        context.addIssue({ code: z.ZodIssueCode.custom, path: ["fieldId"], message: "Only field policies can target a field" });
    }

    if (policy.scopeType !== "list" && policy.rowFilter) {
        context.addIssue({ code: z.ZodIssueCode.custom, path: ["rowFilter"], message: "Data limits can only be attached to list policies" });
    }
}

export const UpsertCollectionAccessPolicySchema = CollectionAccessPolicyWriteSchema
    .superRefine(validateCollectionAccessPolicyShape);

export const DeleteCollectionAccessPolicySchema = z.object({
    tenantId: z.string().min(1),
    policyId: z.string().min(1),
});

export const ListCollectionAccessTeamMembersSchema = z.object({
    tenantId: z.string().min(1),
    teamId: z.string().min(1),
});

export const SetCollectionAccessTeamMembersSchema = z.object({
    tenantId: z.string().min(1),
    teamId: z.string().min(1),
    userIds: z.array(z.string().min(1)).max(1_000),
});

export const PreviewCollectionAccessPolicySchema = z.object({
    tenantId: z.string().min(1),
    dataModelId: z.string().min(1),
    collectionId: z.string().optional(),
    policy: CollectionAccessPolicyWriteSchema.omit({
        tenantId: true,
        dataModelId: true,
        policyId: true,
    }).extend({
        dataModelId: z.string().optional(),
        collectionId: z.string().optional(),
    }).superRefine(validateCollectionAccessPolicyShape),
    record: z.record(z.string(), z.unknown()).optional(),
});

const CollectionCollaborationRecordScopeSchema = z.object({
    tenantId: z.string().min(1),
    collectionId: z.string().min(1),
    recordId: z.string().min(1),
});

const CollectionCollaborationRequestIdSchema = z.string().max(191).optional();

export const CreateCollectionCommentSchema = CollectionCollaborationRecordScopeSchema.extend({
    body: z.string().trim().min(1).max(10_000),
    parentId: z.string().min(1).optional(),
    mentionUserIds: z.array(z.string().min(1)).max(25).optional(),
    requestId: CollectionCollaborationRequestIdSchema,
});

export const UpdateCollectionCommentSchema = CollectionCollaborationRecordScopeSchema.extend({
    commentId: z.string().min(1),
    body: z.string().trim().min(1).max(10_000),
    mentionUserIds: z.array(z.string().min(1)).max(25).optional(),
    requestId: CollectionCollaborationRequestIdSchema,
});

export const DeleteCollectionCommentSchema = CollectionCollaborationRecordScopeSchema.extend({
    commentId: z.string().min(1),
    requestId: CollectionCollaborationRequestIdSchema,
});

export const ListCollectionCommentsSchema = CollectionCollaborationRecordScopeSchema.extend({
    limit: z.coerce.number().int().min(1).max(100).optional(),
    offset: z.coerce.number().int().min(0).max(1_000_000).optional(),
});

export const ListCollectionRecordActivitySchema = ListCollectionCommentsSchema;

export const ListCollectionRecordCollaboratorsSchema = CollectionCollaborationRecordScopeSchema;

export const SetCollectionRecordCollaboratorsSchema = CollectionCollaborationRecordScopeSchema.extend({
    assigneeIds: z.array(z.string().min(1)).max(20),
    watcherIds: z.array(z.string().min(1)).max(100),
    requestId: CollectionCollaborationRequestIdSchema,
});

export const ListCollectionNotificationsSchema = z.object({
    tenantId: z.string().min(1),
    limit: z.coerce.number().int().min(1).max(50).optional(),
    offset: z.coerce.number().int().min(0).max(1_000_000).optional(),
    unreadOnly: z.boolean().optional(),
});

export const MarkCollectionNotificationsReadSchema = z.object({
    tenantId: z.string().min(1),
    notificationIds: z.array(z.string().min(1)).max(100),
});

export const ListRecordPermissionsSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    recordId: z.string(),
    actor: z.string().optional(),
    subjectType: z.string().optional(),
    subjectId: z.string().optional(),
});

const RecordPermissionScopeSchema = z.object({
    tenantId: z.string(),
    collectionId: z.string(),
    recordId: z.string(),
});

export const GrantRecordPermissionSchema = z.union([
    RecordPermissionScopeSchema.extend({
        // Canonical public shape.
        subjectType: z.string(), // user | role | group | service | custom
        subjectId: z.string(),
        actions: z.array(z.string()).min(1),
        effect: z.enum(["allow", "deny"]).optional(),
        grantedBy: z.string().optional(),
        actor: z.string().optional(),
        action: z.string().optional(),
    }),
    RecordPermissionScopeSchema.extend({
        // Compatibility with the original single-action backend contract.
        actor: z.string(),
        action: z.string(),
        effect: z.enum(["allow", "deny"]).optional(),
        grantedBy: z.string().optional(),
        subjectType: z.string().optional(),
        subjectId: z.string().optional(),
        actions: z.array(z.string()).optional(),
    }),
]);

export const RevokeRecordPermissionSchema = z.union([
    RecordPermissionScopeSchema.extend({
        // Canonical public shape.
        subjectType: z.string(), // user | role | group | service | custom
        subjectId: z.string(),
        // tamamını kaldırmak için ["*"] gönderilebilir
        actions: z.array(z.string()).min(1),
        revokedBy: z.string().optional(),
        actor: z.string().optional(),
        action: z.string().optional(),
    }),
    RecordPermissionScopeSchema.extend({
        // Compatibility with the original single-action backend contract.
        actor: z.string(),
        action: z.string(),
        revokedBy: z.string().optional(),
        subjectType: z.string().optional(),
        subjectId: z.string().optional(),
        actions: z.array(z.string()).optional(),
    }),
]);



//---wiki--------------------------------

export const CreateWikiPageSchema = z.object({
    tenantId: z.string(),
    workspaceId: z.string(),

    title: z.string(),
    slug: z.string(),

    description: z.string().optional(),
    icon: z.string().nullable().optional(),
    iconColor: z.string().nullable().optional(),
    parentId: z.string().nullable().optional(),
    nodeType: z.enum(["DOCUMENT", "FOLDER"]).optional(),
});


export const UpdateWikiPageSchema = z.object({
    id: z.string(),
    title: z.string().optional(),
    slug: z.string().optional(),
    description: z.string().optional(),
    icon: z.string().nullable().optional(),
    iconColor: z.string().nullable().optional(),
    parentId: z.string().nullable().optional(),
    status: z.string().optional(),
    fullPageWidth: z.boolean().optional(),
});

export const DeleteWikiPageSchema = z.object({
    id: z.string(),
});

export const MoveWikiPageSchema = z.object({
    id: z.string(),
    parentId: z.string().nullable().optional(),
    beforeId: z.string().nullable().optional(),
    afterId: z.string().nullable().optional(),
});

export const RestoreWikiPageSchema = z.object({
    id: z.string(),
});

export const GetWikiPageByIdSchema = z.object({
    id: z.string(),
});

export const GetWikiPageBySlugSchema = z.object({
    tenantId: z.string(),
    slug: z.string(),
});

export const GetWikiTreeSchema = z.object({
    tenantId: z.string(),
    workspaceId: z.string(),
});

/* Wiki Revision */

export const CreateWikiRevisionSchema = z.object({
    pageId: z.string(),
    content: z.string(), // JSON.stringify edilmiş Tiptap content
    format: z.string().optional(), // TIPTAP | MARKDOWN | HTML
    createdBy: z.string().optional(),
});

export const GetLatestWikiRevisionSchema = z.object({
    pageId: z.string(),
});

export const GetWikiRevisionByIdSchema = z.object({
    id: z.string(),
});

export const ListWikiPagesSchema = z.object({
    tenantId: z.string(),
    workspaceId: z.string(),
});

export const ListWikiSpacesSchema = z.object({
    tenantId: z.string(),
});

export const CreateWikiSpaceSchema = z.object({
    tenantId: z.string(),
    name: z.string().min(1),
    description: z.string().nullable().optional(),
    icon: z.string().nullable().optional(),
    iconColor: z.string().nullable().optional(),
    visibility: z.string().nullable().optional(),
});

export const UpdateWikiSpaceSchema = z.object({
    id: z.string(),
    name: z.string().min(1).nullable().optional(),
    description: z.string().nullable().optional(),
    icon: z.string().nullable().optional(),
    iconColor: z.string().nullable().optional(),
});

export const DeleteWikiSpaceSchema = z.object({
    id: z.string(),
});

export const GetPrivateWikiSpaceSchema = z.object({
    tenantId: z.string(),
});

export const GetWikiAiSettingsSchema = z.object({
    tenantId: z.string(),
    workspaceId: z.string().nullable().optional(),
});

export const SetWikiAiSettingsSchema = z.object({
    tenantId: z.string(),
    workspaceId: z.string().nullable().optional(),
    credentialId: z.string().nullable().optional(),
    chatModelName: z.string().optional(),
    modelName: z.string().optional(),
    llmModel: z.string().optional(),
    llmModelConfig: z.record(z.string(), z.unknown()).nullable().optional(),
});

export const ListWikiAiCommandsSchema = z.object({
    tenantId: z.string(),
    workspaceId: z.string().nullable().optional(),
});

export const CreateWikiAiCommandSchema = z.object({
    tenantId: z.string(),
    workspaceId: z.string().nullable().optional(),
    title: z.string(),
    prompt: z.string(),
    icon: z.string().nullable().optional(),
    description: z.string().nullable().optional(),
});

export const RunWikiAiCommandSchema = z.object({
    tenantId: z.string(),
    workspaceId: z.string().nullable().optional(),
    commandId: z.string(),
    editorContent: z.string(),
    selectedText: z.string().nullable().optional(),
    customPrompt: z.string().nullable().optional(),
});

export const SetWikiPageUserStateSchema = z.object({
    pageId: z.string(),
    isFavorite: z.boolean().optional(),
    isWatching: z.boolean().optional(),
    userId: z.string().optional(),
});

export const UploadEditorFileSchema = z.object({
    fileName: z.string(),
    fileType: z.string().optional(),
    fileData: z.string(),
    pageId: z.string().optional(),
    attachmentId: z.string().optional(),
});

export const ResolveWikiFileViewSchema = z.object({
    fileId: z.string(),
});

export const ResolveScopeFileViewSchema = z.object({
    fileId: z.string(),
});

export const CreateWikiCommentSchema = z.object({
    pageId: z.string(),
    content: z.string(),
    creatorId: z.string(),
    creatorName: z.string().optional(),
    creatorAvatarUrl: z.string().optional(),
    selection: z.string().optional(),
    parentCommentId: z.string().nullable().optional(),
});

export const UpdateWikiCommentSchema = z.object({
    commentId: z.string(),
    content: z.string().optional(),
    resolved: z.boolean().optional(),
    resolvedById: z.string().optional(),
    resolvedByName: z.string().optional(),
    resolvedByAvatarUrl: z.string().optional(),
});

export const DeleteWikiCommentSchema = z.object({
    commentId: z.string(),
});

export const ListWikiCommentsSchema = z.object({
    pageId: z.string(),
    page: z.number().int().optional(),
    limit: z.number().int().optional(),
});

export const CreateWikiReferenceSchema = z.object({
    tenantId: z.string(),
    workspaceId: z.string().optional(),
    pageId: z.string().optional(),
    type: z.string(),
    name: z.string().optional(),
    content: z.string(),
    previewContent: z.string().optional(),
    createdBy: z.string().optional(),
});

export const UpdateWikiReferenceSchema = z.object({
    id: z.string(),
    type: z.string().optional(),
    name: z.string().optional(),
    content: z.string().optional(),
    previewContent: z.string().optional(),
    updatedBy: z.string().optional(),
});

export const GetWikiReferenceByIdSchema = z.object({
    id: z.string(),
});

export const ListWikiReferencesSchema = z.object({
    tenantId: z.string(),
    workspaceId: z.string().optional(),
    pageId: z.string().optional(),
    type: z.string().optional(),
    limit: z.number().int().optional(),
    offset: z.number().int().optional(),
});

export const DeleteWikiReferenceSchema = z.object({
    id: z.string(),
    updatedBy: z.string().optional(),
});

export const CreateDatasourceSchema = z.object({
    tenantId: z.string(),
    entityId: z.string(),
    name: z.string(),
    description: z.string().optional(),
    type: z.string(),
    config: z.object({}).optional(),
});

export const UpdateDatasourceSchema = z.object({
    id: z.string(),
    name: z.string().optional(),
    description: z.string().optional(),
    config: z.object({}).optional(),
});

export const DeleteDatasourceSchema = z.object({
    id: z.string(),
});

export const ListDatasourcesSchema = z.object({
    tenantId: z.string(),
    entityId: z.string().optional()
});

export const CreateSkillSchema = z.object({
    tenantId: z.string(),
    entityId: z.string(),
    name: z.string(),
    description: z.string().optional(),
    type: z.string(),
    config: z.object({}).optional(),
});

export const UpdateSkillSchema = z.object({
    id: z.string(),
    name: z.string().optional(),
    description: z.string().optional(),
    config: z.object({}).optional(),
});

export const DeleteSkillSchema = z.object({
    id: z.string(),
});

export const ListSkillsSchema = z.object({
    tenantId: z.string(),
    entityId: z.string().optional()
});

export const CreateChannelSchema = z.object({
    tenantId: z.string(),
    entityId: z.string(),
    name: z.string(),
    description: z.string().optional(),
    type: z.string(),
    config: z.object({}).optional(),
});

export const UpdateChannelSchema = z.object({
    id: z.string(),
    name: z.string().optional(),
    description: z.string().optional(),
    config: z.object({}).optional(),
});

export const DeleteChannelSchema = z.object({
    id: z.string(),
});

export const ListChannelsSchema = z.object({
    tenantId: z.string(),
    entityId: z.string().optional()
});

export const SendWorkerWhatsAppMessageSchema = z.object({
    tenantId: z.string().min(1),
    workerId: z.string().min(1),
    channelId: z.string().min(1).optional(),
    to: z.string().regex(/^(?:whatsapp:)?\+[1-9]\d{6,14}$/),
    body: z.string().min(1).refine((value) => Array.from(value).length <= 1600, 'WhatsApp body must be at most 1,600 characters.').optional(),
    contentSid: z.string().regex(/^HX[a-fA-F0-9]{32}$/).optional(),
    contentVariables: z.record(z.string(), z.unknown()).optional(),
    idempotencyKey: z.string().min(1).max(255)
}).refine((value) => Boolean(value.body) !== Boolean(value.contentSid), {
    message: 'Provide exactly one of body or contentSid.'
});

export const TestWorkerWhatsAppChannelSchema = z.object({
    tenantId: z.string().min(1),
    channelId: z.string().min(1)
});

export const ListWorkerWhatsAppMessagesSchema = z.object({
    tenantId: z.string().min(1),
    workerId: z.string().min(1),
    channelId: z.string().min(1).optional(),
    cursor: z.string().min(1).optional(),
    limit: z.string().regex(/^\d+$/).optional()
});

export const SendWorkerSlackMessageSchema = z.object({
    tenantId: z.string().min(1),
    workerId: z.string().min(1),
    channelId: z.string().min(1).optional(),
    conversationId: z.string().regex(/^[CGD][A-Z0-9]{8,}$/),
    body: z.string().min(1).refine((value) => Array.from(value).length <= 4000, 'Slack body must be at most 4,000 characters.'),
    threadTs: z.string().regex(/^\d{10,}\.\d{6}$/).optional(),
    idempotencyKey: z.string().min(1).max(255)
});

export const TestWorkerSlackChannelSchema = z.object({
    tenantId: z.string().min(1),
    channelId: z.string().min(1)
});

export const ListSlackConversationsSchema = z.object({
    tenantId: z.string().min(1),
    credentialRef: z.string().min(1)
});

export const ListWorkerSlackMessagesSchema = z.object({
    tenantId: z.string().min(1),
    workerId: z.string().min(1),
    channelId: z.string().min(1).optional(),
    cursor: z.string().min(1).optional(),
    limit: z.string().regex(/^\d+$/).optional()
});

export const SendWorkerDiscordMessageSchema = z.object({
    tenantId: z.string().min(1),
    workerId: z.string().min(1),
    channelId: z.string().min(1).optional(),
    conversationId: z.string().regex(/^\d{17,20}$/),
    body: z.string().min(1).refine((value) => Array.from(value).length <= 2000, 'Discord body must be at most 2,000 characters.'),
    replyToMessageId: z.string().regex(/^\d{17,20}$/).optional(),
    idempotencyKey: z.string().min(1).max(255)
});

export const TestWorkerDiscordChannelSchema = z.object({
    tenantId: z.string().min(1),
    channelId: z.string().min(1)
});

export const ListDiscordGuildsSchema = z.object({
    tenantId: z.string().min(1),
    credentialRef: z.string().min(1)
});

export const ListDiscordGuildChannelsSchema = z.object({
    tenantId: z.string().min(1),
    credentialRef: z.string().min(1),
    guildId: z.string().regex(/^\d{17,20}$/)
});

export const ListWorkerDiscordMessagesSchema = z.object({
    tenantId: z.string().min(1),
    workerId: z.string().min(1),
    channelId: z.string().min(1).optional(),
    cursor: z.string().min(1).optional(),
    limit: z.string().regex(/^\d+$/).optional()
});

export const ListGoogleMeetCalendarsSchema = z.object({
    tenantId: z.string(),
    credentialId: z.string(),
});

export const GetGoogleMeetBrowserBotAvailabilitySchema = z.object({
    tenantId: z.string(),
    credentialId: z.string().optional(),
});

export const ListGoogleMeetEmailApprovalsSchema = z.object({
    tenantId: z.string(),
    channelId: z.string(),
    includeResolved: z.boolean().optional(),
});

export const ResolveGoogleMeetEmailApprovalSchema = z.object({
    tenantId: z.string(),
    channelId: z.string(),
    deliveryId: z.string(),
    decision: z.enum(["APPROVE", "REJECT"]),
});

export const TestGoogleMeetCredentialSchema = z.object({
    tenantId: z.string(),
    credentialId: z.string(),
});

export const CreateKnowledgeSchema = z.object({
    tenantId: z.string(),
    entityId: z.string(),
    entityType: z.string(),
    name: z.string(),
    description: z.string().optional(),
    loaderId: z.string(),
    config: z.object({}).optional(),
});

export const UpdateKnowledgeSchema = z.object({
    id: z.string(),
    name: z.string().optional(),
    description: z.string().optional(),
    config: z.object({}).optional(),
});

export const DeleteKnowledgeSchema = z.object({
    id: z.string(),
});

export const ListKnowledgesSchema = z.object({
    tenantId: z.string(),
    entityId: z.string().optional()
});


export const CreateWorkerTopicSchema = z.object({
    id: z.string(),
    workerId: z.string(),
    title: z.string(),
    prompt: z.string().optional(),
    instructions: z.array(z.string()).optional(),
});

export const UpdateWorkerTopicSchema = z.object({
    id: z.string(),
    title: z.string(),
    prompt: z.string().optional(),
    instructions: z.array(z.string()).optional(),
});

export const DeleteWorkerTopicSchema = z.object({
    id: z.string()
});

export const ListWorkerTopicsSchema = z.object({
    tenantId: z.string(),
    workerId: z.string().optional()
});

export const CreateWorkerNotebookSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
    name: z.string(),
    description: z.string().nullable().optional(),
    createdBy: z.string().nullable().optional(),
});

export const ListWorkerNotebooksSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
});

export const GetWorkerNotebookSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
    notebookId: z.string(),
});

export const BuildWorkerNotebookContextSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
    notebookId: z.string(),
    contextConfig: z.record(z.string(), z.unknown()).nullable().optional(),
});

export const UpdateWorkerNotebookSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
    notebookId: z.string(),
    name: z.string().nullable().optional(),
    description: z.string().nullable().optional(),
});

export const DeleteWorkerNotebookSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
    notebookId: z.string(),
});

export const CreateWorkerNotebookSourceSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
    notebookId: z.string(),
    type: z.string().nullable().optional(),
    title: z.string(),
    url: z.string().nullable().optional(),
    content: z.string().nullable().optional(),
    metadata: z.record(z.string(), z.unknown()).nullable().optional(),
    transformations: z.array(z.string()).nullable().optional(),
    embed: z.boolean().nullable().optional(),
});

export const CreateWorkerNotebookFileSourceSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
    notebookId: z.string(),
    fileName: z.string(),
    fileType: z.string().nullable().optional(),
    fileData: z.string(),
    attachmentId: z.string().nullable().optional(),
    transformations: z.array(z.string()).nullable().optional(),
    embed: z.boolean().nullable().optional(),
});

export const DiscoverWorkerNotebookSourcesSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
    notebookId: z.string(),
    query: z.string(),
    limit: z.number().int().nullable().optional(),
    sourceType: z.string().nullable().optional(),
    researchMode: z.string().nullable().optional(),
});

export const ImportWorkerNotebookSourcesSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
    notebookId: z.string(),
    urls: z.union([z.array(z.string()), z.string()]),
    transformations: z.array(z.string()).nullable().optional(),
    embed: z.boolean().nullable().optional(),
});

export const UpdateWorkerNotebookSourceSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
    notebookId: z.string(),
    sourceId: z.string(),
    title: z.string().nullable().optional(),
    url: z.string().nullable().optional(),
    content: z.string().nullable().optional(),
    metadata: z.record(z.string(), z.unknown()).nullable().optional(),
    status: z.string().nullable().optional(),
});

export const DeleteWorkerNotebookSourceSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
    notebookId: z.string(),
    sourceId: z.string(),
});

export const SendWorkerNotebookMessageSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
    notebookId: z.string(),
    content: z.string(),
    role: z.string().optional().nullable(),
    metadata: z.record(z.string(), z.unknown()).optional().nullable(),
});

export const ClearWorkerNotebookMessagesSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
    notebookId: z.string(),
});

export const CreateWorkerNotebookNoteSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
    notebookId: z.string(),
    title: z.string(),
    content: z.string().nullable().optional(),
});

export const DeleteWorkerNotebookNoteSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
    notebookId: z.string(),
    noteId: z.string(),
});

export const CreateWorkerNotebookStudioOutputSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
    notebookId: z.string(),
    type: z.string(),
    title: z.string(),
    content: z.string().nullable().optional(),
    metadata: z.record(z.string(), z.unknown()).nullable().optional(),
});

export const UpdateWorkerNotebookStudioOutputSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
    notebookId: z.string(),
    outputId: z.string(),
    title: z.string().nullable().optional(),
    content: z.string().nullable().optional(),
    metadata: z.record(z.string(), z.unknown()).nullable().optional(),
});

export const DeleteWorkerNotebookStudioOutputSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
    notebookId: z.string(),
    outputId: z.string(),
});

export const CreateTopicSchema = z.object({
    tenantId: z.string(),
    entityId: z.string(),
    entityType: z.string(),
    title: z.string(),
    prompt: z.string().optional(),
    instructions: z.array(z.string()).optional(),
    category: z.string(),
});

export const UpdateTopicSchema = z.object({
    id: z.string(),
    title: z.string(),
    prompt: z.string().optional(),
    instructions: z.array(z.string()).optional(),
    category: z.string().optional(),
});

export const DeleteTopicSchema = z.object({
    id: z.string()
});

export const ListTopicsSchema = z.object({
    tenantId: z.string(),
    entityId: z.string().optional()
});

export const ListChatHistorySchema = z.object({
    tenantId: z.string(),
});

export const PublishEmploidSchema = z.object({
    tenantId: z.string(),
    emploidId: z.string(),
});

export const PublishWorkerToMarketStoreSchema = z.object({
    tenantId: z.string(),
    workerId: z.string(),
});

export const ListMarketStoreItemsSchema = z.object({
    tenantId: z.string(),
});

export const GetMarketStoreItemSchema = z.object({
    id: z.string(),
});

export const EnhanceTopicSchema = z.object({
    entityName: z.string(),
    entityDescription: z.string(),
    categories: z.string().array().optional()
})

export const CollectionFormLayoutFieldSchema = z.object({
    fieldId: z.string().trim().min(1).max(191),
    label: z.string().max(255).optional(),
    helpText: z.string().max(1_000).optional(),
    placeholder: z.string().max(500).optional(),
    required: z.boolean().optional(),
    width: z.enum(["full", "half"]).optional(),
}).strict();

export const CollectionFormLayoutSectionSchema = z.object({
    id: z.string().trim().min(1).max(128),
    title: z.string().max(255).optional(),
    description: z.string().max(2_000).optional(),
    fields: z.array(CollectionFormLayoutFieldSchema).max(50),
}).strict();

export const CollectionFormLayoutSchema = z.object({
    sections: z.array(CollectionFormLayoutSectionSchema).min(1).max(10),
}).strict().superRefine((layout, context) => {
    const sectionIds = new Set<string>();
    const fieldIds = new Set<string>();
    let fieldCount = 0;
    layout.sections.forEach((section, sectionIndex) => {
        if (sectionIds.has(section.id)) {
            context.addIssue({
                code: z.ZodIssueCode.custom,
                path: ["sections", sectionIndex, "id"],
                message: "Form section ids must be unique",
            });
        }
        sectionIds.add(section.id);
        section.fields.forEach((field, fieldIndex) => {
            fieldCount += 1;
            if (fieldIds.has(field.fieldId)) {
                context.addIssue({
                    code: z.ZodIssueCode.custom,
                    path: ["sections", sectionIndex, "fields", fieldIndex, "fieldId"],
                    message: "A field can appear only once in a form",
                });
            }
            fieldIds.add(field.fieldId);
        });
    });
    if (fieldCount === 0 || fieldCount > 50) {
        context.addIssue({
            code: z.ZodIssueCode.custom,
            path: ["sections"],
            message: "A form must contain between 1 and 50 fields",
        });
    }
});

export const ListCollectionFormsSchema = z.object({
    tenantId: z.string().min(1),
    dataModelId: z.string().min(1),
    collectionId: z.string().min(1),
});

export const UpsertCollectionFormSchema = z.object({
    tenantId: z.string().min(1),
    dataModelId: z.string().min(1),
    collectionId: z.string().min(1),
    formId: z.string().min(1).optional(),
    name: z.string().trim().min(1).max(191),
    description: z.string().max(10_000).optional(),
    layout: CollectionFormLayoutSchema,
    submitLabel: z.string().trim().min(1).max(100).optional(),
    successMessage: z.string().trim().min(1).max(2_000).optional(),
    enabled: z.boolean().optional(),
    rateLimitPerMinute: z.number().int().min(1).max(100).optional(),
    maxSubmissions: z.number().int().min(1).max(1_000_000).nullable().optional(),
});

export const ResolveCollectionFormSchema = z.object({
    tenantId: z.string().min(1),
    formId: z.string().min(1),
});

export const SubmitCollectionFormSchema = ResolveCollectionFormSchema.extend({
    values: z.record(z.string(), z.unknown()).refine(
        (values) => Object.keys(values).length <= 50,
        "A form submission can contain at most 50 fields"
    ),
    submissionKey: z.string().trim().min(8).max(128),
});

export const PublishCollectionFormSchema = ResolveCollectionFormSchema.extend({
    expiresInDays: z.number().int().min(1).max(365).optional(),
});

export const RevokeCollectionFormSchema = ResolveCollectionFormSchema;
export const DeleteCollectionFormSchema = ResolveCollectionFormSchema;

export const CollectionReportTypeSchema = z.enum(["table", "metric", "chart"]);
export const CollectionReportVisibilitySchema = z.enum(["personal", "shared"]);
const CollectionReportFilterSchema = z.record(z.string(), z.unknown()).superRefine((filter, context) => {
    if (JSON.stringify(filter).length > 16 * 1024) {
        context.addIssue({ code: z.ZodIssueCode.custom, message: "Report filter is too large" });
    }
});
const CollectionReportBaseSchema = z.object({
    tenantId: z.string().min(1),
    dataModelId: z.string().min(1),
    collectionId: z.string().min(1),
    reportId: z.string().min(1).optional(),
    name: z.string().trim().min(1).max(191),
    description: z.string().max(4_000).optional(),
    visibility: CollectionReportVisibilitySchema.optional(),
});
export const CollectionReportTableConfigSchema = z.object({
    filter: CollectionReportFilterSchema.optional(),
    fields: z.array(z.string().min(1)).min(1).max(50),
    sort: z.record(z.string(), z.enum(["asc", "desc"])).refine(
        (sort) => Object.keys(sort).length <= 5,
        "Report sort cannot contain more than 5 fields"
    ).optional(),
    limit: z.number().int().min(1).max(500).optional(),
}).strict();
const CollectionReportAggregateConfigBaseSchema = z.object({
    filter: CollectionReportFilterSchema.optional(),
    aggregate: z.enum(["count", "sum", "avg", "min", "max"]),
    valueField: z.string().min(1).optional(),
});
export const CollectionReportMetricConfigSchema = CollectionReportAggregateConfigBaseSchema.extend({
    limit: z.literal(1).optional(),
}).strict().superRefine((config, context) => {
    if (config.aggregate !== "count" && !config.valueField) {
        context.addIssue({ code: z.ZodIssueCode.custom, path: ["valueField"], message: "This aggregate requires valueField" });
    }
});
export const CollectionReportChartConfigSchema = CollectionReportAggregateConfigBaseSchema.extend({
    groupBy: z.string().min(1),
    limit: z.number().int().min(1).max(100).optional(),
}).strict().superRefine((config, context) => {
    if (config.aggregate !== "count" && !config.valueField) {
        context.addIssue({ code: z.ZodIssueCode.custom, path: ["valueField"], message: "This aggregate requires valueField" });
    }
});
export const UpsertCollectionReportSchema = z.discriminatedUnion("type", [
    CollectionReportBaseSchema.extend({ type: z.literal("table"), config: CollectionReportTableConfigSchema }),
    CollectionReportBaseSchema.extend({ type: z.literal("metric"), config: CollectionReportMetricConfigSchema }),
    CollectionReportBaseSchema.extend({ type: z.literal("chart"), config: CollectionReportChartConfigSchema }),
]);
export const ListCollectionReportsSchema = z.object({
    tenantId: z.string().min(1),
    dataModelId: z.string().min(1),
    collectionId: z.string().min(1),
    limit: z.number().int().min(1).max(200).optional(),
    offset: z.number().int().min(0).max(10_000).optional(),
});
export const CollectionReportReferenceSchema = z.object({
    tenantId: z.string().min(1),
    reportId: z.string().min(1),
});
export const DeleteCollectionReportSchema = CollectionReportReferenceSchema;
export const EvaluateCollectionReportSchema = CollectionReportReferenceSchema;

const CollectionDashboardWidgetBaseSchema = z.object({
    id: z.string().min(1).optional(),
    reportId: z.string().min(1),
    title: z.string().trim().min(1).max(191),
});
export const CollectionDashboardWidgetSchema = z.discriminatedUnion("type", [
    CollectionDashboardWidgetBaseSchema.extend({
        type: z.literal("table"),
        config: z.object({
            pageSize: z.number().int().min(1).max(100).optional(),
            showHeaders: z.boolean().optional(),
        }).strict().optional(),
    }),
    CollectionDashboardWidgetBaseSchema.extend({
        type: z.literal("metric"),
        config: z.object({
            prefix: z.string().max(32).optional(),
            suffix: z.string().max(32).optional(),
            decimals: z.number().int().min(0).max(6).optional(),
        }).strict().optional(),
    }),
    CollectionDashboardWidgetBaseSchema.extend({
        type: z.literal("chart"),
        config: z.object({
            kind: z.enum(["bar", "line", "pie"]).optional(),
            showLegend: z.boolean().optional(),
        }).strict().optional(),
    }),
]);
export const ListCollectionDashboardsSchema = z.object({
    tenantId: z.string().min(1),
    dataModelId: z.string().min(1),
    collectionId: z.string().min(1),
    limit: z.number().int().min(1).max(100).optional(),
    offset: z.number().int().min(0).max(10_000).optional(),
});
export const UpsertCollectionDashboardSchema = z.object({
    tenantId: z.string().min(1),
    dataModelId: z.string().min(1),
    collectionId: z.string().min(1),
    dashboardId: z.string().min(1).optional(),
    name: z.string().trim().min(1).max(191),
    description: z.string().max(4_000).optional(),
    settings: z.object({
        columns: z.number().int().min(1).max(4).optional(),
        compact: z.boolean().optional(),
    }).strict().optional(),
    visibility: CollectionReportVisibilitySchema.optional(),
    widgets: z.array(CollectionDashboardWidgetSchema).max(20),
});
export const CollectionDashboardReferenceSchema = z.object({
    tenantId: z.string().min(1),
    dashboardId: z.string().min(1),
});
export const DeleteCollectionDashboardSchema = CollectionDashboardReferenceSchema;
export const EvaluateCollectionDashboardSchema = CollectionDashboardReferenceSchema;

export const PreviewCollectionAppGenerationSchema = z.object({
    tenantId: z.string().trim().min(1).max(191),
    prompt: z.string().trim().min(1).max(4_000),
}).strict();

export const ApplyCollectionAppGenerationSchema = z.object({
    tenantId: z.string().trim().min(1).max(191),
    planId: z.string().trim().min(1).max(191),
    expectedProposalHash: z.string().regex(/^[a-f0-9]{64}$/),
    idempotencyKey: z.string().trim().min(8).max(128),
}).strict();

export const RollbackCollectionAppGenerationSchema = z.object({
    tenantId: z.string().trim().min(1).max(191),
    runId: z.string().trim().min(1).max(191),
    idempotencyKey: z.string().trim().min(8).max(128),
}).strict();

export const ResumeCollectionAppGenerationRunSchema = z.object({
    tenantId: z.string().trim().min(1).max(191),
    runId: z.string().trim().min(1).max(191),
}).strict();

export const GetCollectionAppGenerationPlanSchema = z.object({
    tenantId: z.string().trim().min(1).max(191),
    planId: z.string().trim().min(1).max(191),
}).strict();

export const ListCollectionAppGenerationPlansSchema = z.object({
    tenantId: z.string().trim().min(1).max(191),
    status: z.enum(["previewed", "applying", "compensating", "applied", "failed", "compensation_failed", "rollback_retained", "rolled_back"]).optional(),
    offset: z.number().int().min(0).max(1_000_000).optional(),
    limit: z.number().int().min(1).max(50).optional(),
}).strict();

export const GetCollectionAppGenerationRunSchema = z.object({
    tenantId: z.string().trim().min(1).max(191),
    runId: z.string().trim().min(1).max(191),
}).strict();

export const ListCollectionAppGenerationRunsSchema = z.object({
    tenantId: z.string().trim().min(1).max(191),
    planId: z.string().trim().min(1).max(191).optional(),
    status: z.enum([
        "applying",
        "provisioning",
        "compensating",
        "applied",
        "failed",
        "compensation_failed",
        "rolling_back",
        "rollback_cleanup",
        "rollback_cleanup_failed",
        "rollback_failed",
        "rollback_retained",
        "rolled_back",
    ]).optional(),
    offset: z.number().int().min(0).max(1_000_000).optional(),
    limit: z.number().int().min(1).max(50).optional(),
}).strict();