declare module "iface/event" {
    export interface Author {
        name: string;
        email: string;
    }
    export interface ChangeSummary {
        raw: string;
        files: number;
        inserts: number;
        deletions: number;
    }
    export interface DecodedBase {
        author: Author;
        ticket: string;
        ticketPrefix: string;
        changeSummary: ChangeSummary;
    }
    export interface Decoded extends DecodedBase {
        commit: string;
        commitId: string;
        date: string;
        message: string;
        changes: string | string[];
    }
    /**
     * Base increment event structure. There might be multiple increments (like code increment
     * aka commit, or some content increments like working on JIRA issue)
     */
    export interface EventBase {
        id: string;
        version: string;
        oper: string;
        account: string;
        user: string;
        project: string;
        decoded: DecodedBase;
        ct: number;
        tenantId: string;
        diff: any;
    }
    /**
     * Represents a "commit" event
     */
    export interface Event extends EventBase {
        remote: string;
        oper: "commit" | "push";
        decoded: Decoded;
        gitlog: string;
        diff: string;
    }
}
declare module "iface/content" {
    import { DecodedBase, EventBase } from "iface/event";
    export namespace Content {
        enum ContentEventOperEnum {
            JIRA_TICKET = "jira-ticket",
            CONFLU_PAGE = "conflu-page"
        }
        /**
         * Represents an increment/change in content.
         * Usually either we have before and after content or diff content.
         * If we have diff content, then before and after are not required.
         * If we have before and after content, then diff content is not required.
         */
        interface ContentDiff {
            fieldId?: string;
            before?: string;
            after?: string;
            diff?: string;
        }
        interface ContentJiraTicketEvent extends ContentEvent {
            oper: ContentEventOperEnum.JIRA_TICKET;
        }
        interface ContentConfluencPageEvent extends ContentEvent {
            oper: ContentEventOperEnum.CONFLU_PAGE;
        }
        interface DecodedContent extends DecodedBase {
            url?: string;
            projectId?: string;
            reason?: "issue" | "comment" | "page";
        }
        /**
         * Represents an event related to content, such as creating new content or updating existing content.
         * This is a more generic event that can be used for various content-related operations.
         */
        interface ContentEvent extends EventBase {
            decoded: DecodedContent;
            diff: ContentDiff[];
        }
    }
}
declare module "iface/model" {
    import { Event } from "iface/event";
    import { Content } from "iface/content";
    export interface Score {
        id: string;
        model: ScoreModelCard;
        event: Event | Content.ContentEvent;
    }
    export interface ScalarScore extends Score {
        score: number;
    }
    export interface ScalarScoreWithChangeSummary extends ScalarScore {
        files: number;
        inserts: number;
        deletions: number;
    }
    export interface ScoreModelCard {
        name: string;
        version: string;
    }
    export interface ModelParams {
        [key: string]: any;
    }
    export interface ScoreModel extends ScoreModelCard {
        score: (event: Event) => Promise<Score>;
    }
    export interface ContentScoreModel extends ScoreModelCard {
        score: (event: Content.ContentEvent) => Promise<ScalarScoreWithChangeSummary>;
    }
    export namespace Diff {
        interface GitDiffLineChange {
            type: 'added' | 'removed';
            line: string;
        }
        interface GitDiffFile {
            original: string;
            resulting: string;
            changed: GitDiffLineChange[];
        }
        interface GitDiffResult {
            [filePath: string]: GitDiffFile;
        }
    }
    export namespace Halstead {
        interface FileMetrics {
            [filePath: string]: Metrics;
        }
        interface IncrementMetrics {
            files: FileMetrics;
            total: Metrics;
        }
        interface Metrics {
            scaledEffort: number;
            vocabulary: number;
            length: number;
            volume: number;
            difficulty: number;
            effort: number;
            timeToProgram: number;
            deliveredBugs: number;
        }
        interface Score extends ScalarScore {
            increment: IncrementMetrics;
        }
    }
}
declare module "logic/commons" {
    import { Diff } from "iface/model";
    /**
     * Will calculate diff information (resulting code, and original code)
     * for each file from a provided git diff (unified diff format)
     * @param diffText
     * @returns
     */
    export const parseGitDiff: (diffText: string) => Diff.GitDiffResult;
    /**
   * This is a FMW factor function that applies following modification to the score:
   * - Is linear when score < upper
   * - Smoothly flattens and asymptotically approaches border for score ≥ upper
   *
   * f(x)=border−(border−upper)⋅e^(−(x−upper/L)
   * @param score original score <0, inf)
   * @param upper up to upper we do not modify the score, after upper we asymptotically reach border
   * @param border asymptotic border for scores that are greater than upper
   * @param L the bigger the L the slower approach towards border
   * @returns modified score <0, border)
   */
    export const fmwFactor: (score: number, upper?: number, border?: number, L?: number) => number;
}
declare module "q247-models-core" {
    export type { ScalarScore, Score, ScoreModel, ScoreModelCard, ContentScoreModel, ScalarScoreWithChangeSummary, ModelParams } from "iface/model";
    export type { Event, Decoded, Author, ChangeSummary, DecodedBase, EventBase } from "iface/event";
    export { Diff, Halstead } from "iface/model";
    export type { Content } from "iface/content";
    export { parseGitDiff, fmwFactor } from "logic/commons";
}