/**
 * Clockodo client class with typed API endpoint methods and DTOs.
 *
 * @module
 */
import { Api, type Config, type Params, type ParamsWithPage, type ParamsWithSort, type ResponseWithFilter, type ResponseWithoutPaging, type ResponseWithPaging } from "./lib/api.js";
import * as REQUIRED from "./lib/requiredParams.js";
import { type Absence } from "./models/absence.js";
import { type AddAccessGroupParams, type DeleteAccessGroupParams, type EditAccessEntityGeneralParams, type EditAccessEntityGeneralProjectOrServiceParams, type EditAccessEntityParams, type EditAccessEntityProjectOrServiceParams, type EditAccessGroupParams, type UsersAccessCustomersProjects, type UsersAccessServices } from "./models/accessControl.js";
import { type AccessGroup } from "./models/accessGroup.js";
import { type AggregatesUsersMe } from "./models/aggregatesUsersMe.js";
import { type Customer } from "./models/customer.js";
import { type CustomerCountProjects } from "./models/customerCountProjects.js";
import { type EntriesText } from "./models/entriesText.js";
import { Billability, type ClockingTimeEntryBillability, type Entry, type LumpsumServiceEntry, type LumpsumValueEntry, type TimeEntry } from "./models/entry.js";
import { type EntryGroup } from "./models/entryGroup.js";
import { type HolidaysCarryover } from "./models/holidaysCarryover.js";
import { type HolidaysQuota } from "./models/holidaysQuota.js";
import { type LumpsumService } from "./models/lumpsumService.js";
import { type NonbusinessDay } from "./models/nonbusinessDay.js";
import { type NonbusinessGroup } from "./models/nonbusinessGroup.js";
import { type OvertimecarryRow } from "./models/overtimecarry.js";
import { type OvertimeReduction } from "./models/overtimeReduction.js";
import { type Project } from "./models/project.js";
import { type Service } from "./models/service.js";
import { type Subproject } from "./models/subproject.js";
import { type Subscription } from "./models/subscription.js";
import { type SurchargeModel } from "./models/surchargeModel.js";
import { type TargethoursRow, type TargethoursRowInput } from "./models/targethours.js";
import { type Team } from "./models/team.js";
import { type User } from "./models/user.js";
import { UserReportType, type UserReport } from "./models/userReport.js";
import { type UsersNonbusinessDay, type UsersNonbusinessGroup } from "./models/usersNonbusinessGroup.js";
import { WorkTimeChangeRequestStatus, type WorkTimeChangeRequest, type WorkTimeDay } from "./models/workTimes.js";
export declare class Clockodo {
    api: Api;
    constructor(config: Config);
    private getAllPagesAndMergeArray;
    /**
     * @deprecated We will remove plugins because we're planing to move away from
     *   axios to fetch()
     */
    use(plugin: (clockodo: Clockodo) => void): void;
    getAbsence(params: Params<{
        id: Absence["id"];
    }>): Promise<AbsenceReturnType>;
    getAbsences(params: Params<AbsencesParams>): Promise<AbsencesReturnType>;
    getUsersAccessCustomersProjects(params: Params<{
        usersId: User["id"];
    }>): Promise<UsersAccessCustomersProjectsReturnType>;
    getUsersAccessServices(params: Params<{
        usersId: User["id"];
    }>): Promise<UsersAccessServicesReturnType>;
    getAccessGroups(params?: Params): Promise<AccessGroupsReturnType>;
    getAccessGroup(params: Params<{
        id: AccessGroup["id"];
    }>): Promise<AccessGroupReturnType>;
    getAccessGroupsCustomersProjects(params: Params<{
        accessGroupsId: AccessGroup["id"];
    }>): Promise<UsersAccessCustomersProjectsReturnType>;
    getAccessGroupsServices(params: Params<{
        accessGroupsId: AccessGroup["id"];
    }>): Promise<UsersAccessServicesReturnType>;
    getIndividualUserAccessCustomersProjects(params: Params<{
        usersId: User["id"];
    }>): Promise<UsersAccessCustomersProjectsReturnType>;
    getIndividualUserAccessServices(params: Params<{
        usersId: User["id"];
    }>): Promise<UsersAccessServicesReturnType>;
    getClock(params?: Params): Promise<ClockReturnType>;
    getCustomer(params: Params<{
        id: Customer["id"];
    }>): Promise<CustomerReturnType>;
    getCustomersPage(params?: Params<CustomersParams & ParamsWithPage>): Promise<CustomersReturnType>;
    getCustomers(params?: Params<CustomersParams>): Promise<ResponseWithoutPaging<CustomersReturnType>>;
    getCustomersCountProjects(params?: Params<CustomersCountProjectsParams>): Promise<CustomersCountProjectsReturnType>;
    getProject(params: Params<{
        id: Project["id"];
    }>): Promise<ProjectReturnType>;
    getProjectsPage(params?: Params<ProjectsParams & ParamsWithPage>): Promise<ProjectsReturnType>;
    getProjects(params?: Params<ProjectsParams>): Promise<ResponseWithoutPaging<ProjectsReturnType>>;
    getProjectsReportsPage(params?: Params<ProjectsReportsParams & ParamsWithPage>): Promise<ProjectsReportsReturnType>;
    getProjectsReports(params?: Params<ProjectsReportsParams>): Promise<ResponseWithoutPaging<ProjectsReportsReturnType>>;
    getSubproject(params: Params<{
        id: Subproject["id"];
    }>): Promise<SubprojectReturnType>;
    getSubprojectsPage(params?: Params<SubprojectsParams & ParamsWithPage>): Promise<SubprojectsReturnType>;
    getSubprojects(params?: Params<SubprojectsParams>): Promise<ResponseWithoutPaging<SubprojectsReturnType>>;
    getEntry(params: Params<{
        id: Entry["id"];
    }>): Promise<EntryReturnType>;
    splitAllEntriesAtMidnight(params: Params<{
        day: string;
        usersId: number;
    }>): Promise<ResponseWithoutPaging<EntriesReturnType>>;
    getEntries(params: Params<EntriesParams>): Promise<ResponseWithoutPaging<EntriesReturnType>>;
    getEntriesPage(params: Params<EntriesParams & ParamsWithPage>): Promise<EntriesReturnType>;
    getEntriesTexts(params: Params<EntriesTextsParams>): Promise<ResponseWithoutPaging<EntriesTextsReturnType>>;
    getEntriesTextsPage(params: Params<EntriesTextsParams & ParamsWithPage>): Promise<EntriesTextsReturnType>;
    getEntryGroups(params: Params<{
        timeSince: string;
        timeUntil: string;
        grouping: Array<string>;
    }>): Promise<EntryGroupsReturnType>;
    getService(params: Params<{
        id: Service["id"];
    }>): Promise<ServiceReturnType>;
    getServices(params?: Params<ServiceParams>): Promise<ResponseWithoutPaging<ServicesReturnType>>;
    getServicesPage(params?: Params<ServiceParams & ParamsWithPage>): Promise<ServicesReturnType>;
    getTeam(params: Params<{
        id: Team["id"];
    }>): Promise<TeamReturnType>;
    getTeamsPage(params?: Params<TeamsParams & ParamsWithPage>): Promise<TeamsReturnType>;
    getTeams(params?: Params<TeamsParams>): Promise<ResponseWithoutPaging<TeamsReturnType>>;
    getLumpSumService(params: Params<{
        id: LumpsumService["id"];
    }>): Promise<LumpsumServiceReturnType>;
    getLumpSumServices(params?: Params<LumpsumServiceParams>): Promise<ResponseWithoutPaging<LumpsumServicesReturnType>>;
    getLumpSumServicesPage(params?: Params<LumpsumServiceParams & ParamsWithPage>): Promise<LumpsumServicesReturnType>;
    getTargethoursRow(params: Params<{
        id: TargethoursRow["id"];
    }>): Promise<TargethoursRowReturnType>;
    getTargethours(params?: Params<{
        usersId?: User["id"] | Array<User["id"]>;
    }>): Promise<TargethoursReturnType>;
    addTargethour(params: Params<AddTargethourParams>): Promise<TargethoursRowReturnType>;
    editTargethour(params: Params<EditTargethourParams>): Promise<TargethoursRowReturnType>;
    deleteTargethour(params: Params<DeleteTargethourParams>): Promise<DeleteReturnType>;
    getUser(params: Params<{
        id: User["id"];
    }>): Promise<UserReturnType>;
    getUsersPage(params?: Params<UsersParams & ParamsWithPage>): Promise<UsersReturnType>;
    getUsers(params?: Params<UsersParams>): Promise<ResponseWithoutPaging<UsersReturnType>>;
    getSurchargeModel(params: Params<{
        id: SurchargeModel["id"];
    }>): Promise<SurchargeModelReturnType>;
    getSurchargeModels(params?: Params): Promise<SurchargeModelsReturnType>;
    getUserReport<GivenUserReportType extends UserReportType = UserReportType.Year>(params: Params<{
        usersId: User["id"];
        year: number;
        type?: GivenUserReportType;
    }>): Promise<UserReportReturnType<GivenUserReportType>>;
    getUserReports<GivenUserReportType extends UserReportType = UserReportType.Year>(params: Params<{
        year: number;
        type?: GivenUserReportType;
    }>): Promise<UserReportsReturnType<GivenUserReportType>>;
    getNonbusinessGroups(params?: Params): Promise<NonbusinessGroupsReturnType>;
    getNonbusinessGroup(params: Params<{
        id: NonbusinessGroup["id"];
    }>): Promise<NonbusinessGroupReturnType>;
    getNonbusinessDays(params: Params<NonbusinessDaysParams>): Promise<NonbusinessDaysReturnType>;
    getNonbusinessDay(params: Params<{
        id: NonbusinessDay["id"];
        year?: number;
    }>): Promise<NonbusinessDayReturnType>;
    getUsersNonbusinessDaysPage(params?: Params<UsersNonbusinessDaysParams & ParamsWithPage>): Promise<UsersNonbusinessDaysReturnType>;
    getUsersNonbusinessDays(params?: Params<UsersNonbusinessDaysParams>): Promise<ResponseWithoutPaging<UsersNonbusinessDaysReturnType>>;
    getUsersNonbusinessGroup(params: Params<{
        id: UsersNonbusinessGroup["id"];
    }>): Promise<UsersNonbusinessGroupReturnType>;
    getUsersNonbusinessGroupsPage(params?: Params<UsersNonbusinessGroupsParams & ParamsWithPage>): Promise<UsersNonbusinessGroupsReturnType>;
    getUsersNonbusinessGroups(params?: Params<UsersNonbusinessGroupsParams>): Promise<ResponseWithoutPaging<UsersNonbusinessGroupsReturnType>>;
    getOvertimeReductions(params?: Params<OvertimeReductionsParams>): Promise<OvertimeReductionsReturnType>;
    getOvertimeReduction(params: Params<{
        id: OvertimeReduction["id"];
    }>): Promise<OvertimeReductionReturnType>;
    getSubscription(params?: Params): Promise<SubscriptionReturnType>;
    getMe(params?: Params): Promise<MeReturnType>;
    addAbsence(params: Params<AddAbsenceParams>): Promise<AbsenceReturnType>;
    addCustomer(params: Params<AddCustomerParams>): Promise<CustomerReturnType>;
    addAccessGroup(params: Params<AddAccessGroupParams>): Promise<AccessGroupReturnType>;
    addLumpsumService(params: Params<AddLumpsumServiceParams>): Promise<LumpsumServiceReturnType>;
    addEntry(params: Params<Pick<TimeEntry, (typeof REQUIRED.ADD_TIME_ENTRY)[number]> | Pick<LumpsumValueEntry, (typeof REQUIRED.ADD_LUMPSUM_VALUE_ENTRY)[number]> | Pick<LumpsumServiceEntry, (typeof REQUIRED.ADD_LUMPSUM_SERVICE_ENTRY)[number]>>): Promise<AddEntryReturnType>;
    addProject(params: Params<AddProjectParams>): Promise<ProjectReturnType>;
    createNextProjectInterval(params: Params<{
        id: Project["id"];
    }>): Promise<SubprojectReturnType>;
    addSubproject(params: Params<AddSubprojectParams>): Promise<SubprojectReturnType>;
    addService(params: Params<AddServiceParams>): Promise<ServiceReturnType>;
    addTeam(params: Params<AddTeamParams>): Promise<TeamReturnType>;
    addUser(params: Params<AddUserParams>): Promise<AddUserReturnType>;
    addSurchargeModel(params: Params<Pick<SurchargeModel, (typeof REQUIRED.ADD_SURCHARGE_MODEL)[number]>>): Promise<SurchargeModelReturnType>;
    addNonbusinessGroup(params: Params<AddNonbusinessGroupParams>): Promise<NonbusinessGroupReturnType>;
    addNonbusinessDay(params: Params<AddNonbusinessDayParams>): Promise<NonbusinessDayReturnType>;
    addUsersNonbusinessGroup(params: Params<AddUsersNonbusinessGroupParams>): Promise<UsersNonbusinessGroupReturnType>;
    addOvertimecarry(params: Params<AddOvertimecarryParams>): Promise<OvertimecarryRowSingleReturnType>;
    addOvertimeReduction(params: Params<AddOvertimeReductionParams>): Promise<OvertimeReductionReturnType>;
    addHolidaysQuota(params: Params<AddHolidaysQuotaParams>): Promise<HolidaysQuotaReturnType>;
    addHolidaysCarryover(params: Params<AddHolidaysCarryoverParams>): Promise<HolidaysCarryoverReturnType>;
    startClock(params: Params<Pick<TimeEntry, (typeof REQUIRED.START_CLOCK)[number]> & {
        /**
         * Billability of the time entry that is about to be created. Omit it if
         * you want to use the project's default.
         */
        billable?: ClockingTimeEntryBillability;
    }>): Promise<ClockStartReturnType>;
    changeClockDuration(params: Params<{
        entriesId: Entry["id"];
        durationBefore: number;
        duration: number;
    }>): Promise<ClockEditReturnType>;
    editAbsence(params: Params<EditAbsenceParams>): Promise<AbsenceReturnType>;
    editCustomer(params: Params<EditCustomerParams>): Promise<CustomerReturnType>;
    editAccessGroup(params: Params<EditAccessGroupParams>): Promise<AccessGroupReturnType>;
    editAccessGroupsCustomer(params: Params<EditAccessEntityParams & {
        accessGroupsId: AccessGroup["id"];
    }>): Promise<UsersAccessCustomersProjectsReturnType>;
    editAccessGroupsCustomersGeneral(params: Params<EditAccessEntityGeneralParams & {
        accessGroupsId: AccessGroup["id"];
    }>): Promise<UsersAccessCustomersProjectsReturnType>;
    editAccessGroupsProject(params: Params<EditAccessEntityProjectOrServiceParams & {
        accessGroupsId: AccessGroup["id"];
    }>): Promise<UsersAccessCustomersProjectsReturnType>;
    editAccessGroupsService(params: Params<EditAccessEntityProjectOrServiceParams & {
        accessGroupsId: AccessGroup["id"];
    }>): Promise<UsersAccessServicesReturnType>;
    editAccessGroupsServicesGeneral(params: Params<EditAccessEntityGeneralProjectOrServiceParams & {
        accessGroupsId: AccessGroup["id"];
    }>): Promise<UsersAccessServicesReturnType>;
    editIndividualUserAccessCustomer(params: Params<EditAccessEntityParams & {
        usersId: User["id"];
    }>): Promise<UsersAccessCustomersProjectsReturnType>;
    editIndividualUserAccessCustomersGeneral(params: Params<EditAccessEntityGeneralParams & {
        usersId: User["id"];
    }>): Promise<UsersAccessCustomersProjectsReturnType>;
    editIndividualUserAccessProject(params: Params<EditAccessEntityProjectOrServiceParams & {
        usersId: User["id"];
    }>): Promise<UsersAccessCustomersProjectsReturnType>;
    editIndividualUserAccessService(params: Params<EditAccessEntityProjectOrServiceParams & {
        usersId: User["id"];
    }>): Promise<UsersAccessServicesReturnType>;
    editIndividualUserAccessServicesGeneral(params: Params<EditAccessEntityGeneralProjectOrServiceParams & {
        usersId: User["id"];
    }>): Promise<UsersAccessServicesReturnType>;
    editLumpsumService(params: Params<EditLumpsumServiceParams>): Promise<LumpsumServiceReturnType>;
    editEntry(params: Params<Pick<Entry, (typeof REQUIRED.EDIT_ENTRY)[number]>>): Promise<EditEntryReturnType>;
    editEntryGroup(params: Params<{
        timeSince: string;
        timeUntil: string;
    }>): Promise<EditEntryGroupsReturnType>;
    editProject(params: Params<EditProjectParams>): Promise<ProjectReturnType>;
    completeProject(params: Params<CompleteProjectParams>): Promise<ProjectDataReturnType>;
    setProjectBilled(params: Params<SetProjectBilledParams>): Promise<ProjectDataReturnType>;
    editSubproject(params: Params<EditSubprojectParams>): Promise<SubprojectReturnType>;
    completeSubproject(params: Params<CompleteSubprojectParams>): Promise<SubprojectReturnType>;
    editService(params: Params<EditServiceParams>): Promise<ServiceReturnType>;
    editTeam(params: Params<EditTeamParams>): Promise<TeamReturnType>;
    editUser(params: Params<EditUserParams>): Promise<UserReturnType>;
    editSurchargeModel(params: Params<Pick<SurchargeModel, (typeof REQUIRED.EDIT_SURCHARGE_MODEL)[number]>>): Promise<SurchargeModelReturnType>;
    editNonbusinessGroup(params: Params<EditNonbusinessGroupParams>): Promise<NonbusinessGroupReturnType>;
    editNonbusinessDay(params: Params<EditNonbusinessDayParams>): Promise<NonbusinessDayReturnType>;
    editOvertimecarry(params: Params<EditOvertimecarryParams>): Promise<OvertimecarryRowSingleReturnType>;
    editOvertimeReduction(params: Params<EditOvertimeReductionParams>): Promise<OvertimeReductionReturnType>;
    editUsersNonbusinessGroup(params: Params<EditUsersNonbusinessGroupParams>): Promise<UsersNonbusinessGroupReturnType>;
    editHolidaysQuota(params: Params<EditHolidaysQuotaParams>): Promise<HolidaysQuotaReturnType>;
    editHolidaysCarryover(params: Params<EditHolidaysCarryoverParams>): Promise<HolidaysCarryoverReturnType>;
    deleteCustomer(params: Params<DeleteCustomerParams>): Promise<DeleteReturnType>;
    deleteAccessGroup(params: Params<DeleteAccessGroupParams>): Promise<DeleteReturnType>;
    deleteProject(params: Params<DeleteProjectParams>): Promise<DeleteReturnType>;
    deleteSubproject(params: Params<DeleteSubprojectParams>): Promise<DeleteReturnType>;
    deleteService(params: Params<DeleteServiceParams>): Promise<DeleteReturnType>;
    deleteUser(params: Params<Pick<User, (typeof REQUIRED.DELETE_USER)[number]>>): Promise<DeleteReturnType>;
    deleteSurchargeModel(params: Params<Pick<SurchargeModel, (typeof REQUIRED.DELETE_SURCHARGE_MODEL)[number]>>): Promise<DeleteReturnType>;
    deleteAbsence(params: Params<Pick<Absence, (typeof REQUIRED.DELETE_ABSENCE)[number]>>): Promise<DeleteReturnType>;
    deleteEntry(params: Params<Pick<Entry, (typeof REQUIRED.DELETE_ENTRY)[number]>>): Promise<DeleteReturnType>;
    deleteLumpsumService(params: Params<DeleteLumpsumServiceParams>): Promise<DeleteReturnType>;
    deleteEntryGroup(params: Params<{
        timeSince: string;
        timeUntil: string;
    }>): Promise<DeleteEntryGroupsReturnType>;
    deleteTeam(params: Params<Pick<Team, (typeof REQUIRED.DELETE_TEAM)[number]>>): Promise<DeleteReturnType>;
    deleteNonbusinessGroup(params: Params<DeleteNonbusinessGroupParams>): Promise<DeleteReturnType>;
    deleteNonbusinessDay(params: Params<DeleteNonbusinessDayParams>): Promise<DeleteReturnType>;
    deleteOvertimecarry(params: Params<DeleteOvertimecarryParams>): Promise<DeleteReturnType>;
    deleteOvertimeReduction(params: Params<DeleteOvertimeReductionParams>): Promise<DeleteReturnType>;
    deleteUsersNonbusinessGroup(params: Params<DeleteUsersNonbusinessGroupParams>): Promise<DeleteReturnType>;
    deleteHolidaysQuota(params: Params<DeleteHolidaysQuotaParams>): Promise<DeleteReturnType>;
    deleteHolidaysCarryover(params: Params<DeleteHolidaysCarryoverParams>): Promise<DeleteReturnType>;
    register(params: Params<{
        companiesName: string;
        name: string;
        email: string;
    }>): Promise<RegisterReturnType>;
    clearIndividualUserAccess(params: Params<{
        usersId: User["id"];
    }>): Promise<DeleteReturnType>;
    stopClock(params: Params<{
        entriesId: Entry["id"];
        usersId?: number;
    }>): Promise<ClockStopReturnType>;
    getWorkTimesPage(params?: Params<WorkTimesParams & ParamsWithPage>): Promise<WorkTimesReturnType>;
    getWorkTimes(params: Params<WorkTimesParams>): Promise<ResponseWithoutPaging<WorkTimesReturnType>>;
    getWorkTimesChangeRequestsPage(params: Params<WorkTimesChangeRequestsParams & ParamsWithPage>): Promise<WorkTimesChangeRequestsReturnType>;
    getWorkTimesChangeRequests(params: Params<WorkTimesChangeRequestsParams>): Promise<ResponseWithoutPaging<WorkTimesChangeRequestsReturnType>>;
    addWorkTimesChangeRequest(params: Params<Pick<Omit<WorkTimeChangeRequest, "id" | "status">, (typeof REQUIRED.ADD_WORK_TIMES_CHANGE_REQUEST)[number]>>): Promise<AddWorkTimesChangeRequestDataReturnType>;
    withdrawWorkTimesChangeRequest(params: Params<Pick<WorkTimeChangeRequest, (typeof REQUIRED.WITHDRAW_WORK_TIMES_CHANGE_REQUEST)[number]>>): Promise<ApproveOrDeclineWorkTimesChangeRequestReturnType>;
    approveWorkTimesChangeRequest(params: Params<Pick<WorkTimeChangeRequest, (typeof REQUIRED.APPROVE_WORK_TIMES_CHANGE_REQUEST)[number]>>): Promise<ApproveOrDeclineWorkTimesChangeRequestReturnType>;
    declineWorkTimesChangeRequest(params: Params<Pick<WorkTimeChangeRequest, (typeof REQUIRED.DECLINE_WORK_TIMES_CHANGE_REQUEST)[number]>>): Promise<ApproveOrDeclineWorkTimesChangeRequestReturnType>;
    getOvertimecarry(params?: Params<OvertimecarryRowParams>): Promise<OvertimecarryRowReturnType>;
    getOvertimecarryRow(params: Params<{
        id: NonNullable<OvertimecarryRow["id"]>;
    }>): Promise<OvertimecarryRowSingleReturnType>;
    getHolidaysQuotas(params?: Params<HolidaysQuotasParams>): Promise<HolidaysQuotasReturnType>;
    getHolidaysQuota(params: Params<{
        id: HolidaysQuota["id"];
    }>): Promise<HolidaysQuotaReturnType>;
    getHolidaysCarryovers(params?: Params<HolidaysCarryoversParams>): Promise<HolidaysCarryoversReturnType>;
    getHolidaysCarryover(params: Params<{
        id: NonNullable<HolidaysCarryover["id"]>;
    }>): Promise<HolidaysCarryoverReturnType>;
}
export type AbsenceReturnType = {
    data: Absence;
};
export type AbsencesReturnType = {
    data: Array<Absence>;
};
export type AddAbsenceParams = {
    dateSince: Absence["dateSince"];
    dateUntil?: Absence["dateUntil"] | null;
    type: NonNullable<Absence["type"]>;
    halfDay?: boolean;
    countHours?: number | null;
    usersId?: User["id"];
    allowOverride?: Array<Absence["id"]>;
    status?: Absence["status"];
    sickNote?: boolean;
    note?: string | null;
    publicNote?: string | null;
};
export type EditAbsenceParams = {
    id: Absence["id"];
    dateSince?: Absence["dateSince"];
    dateUntil?: Absence["dateUntil"];
    type?: NonNullable<Absence["type"]>;
    halfDay?: boolean;
    countHours?: number | null;
    allowOverride?: Array<Absence["id"]>;
    status?: Absence["status"];
    sickNote?: boolean;
    note?: string | null;
    publicNote?: string | null;
};
export type AbsenceScope = "manageableAbsences" | "viewableAbsences";
export type SortIdName = "id" | "-id" | "name" | "-name";
export type SortIdNameActive = "active" | "-active" | "id" | "-id" | "name" | "-name";
export type CustomerProjectScope = "manageAccess";
export type ServiceScope = "manageAccess";
export type UserScope = "manageAbsences" | "viewAbsences" | "manage";
export type UsersSortForIndex = "active" | "-active" | "id" | "-id" | "name" | "-name" | "number" | "-number" | "role" | "-role" | "teams_name" | "-teams_name";
export type AbsencesParams = {
    filter?: {
        year?: Array<number>;
        usersId?: Array<User["id"]>;
        teamsId?: Array<null | Team["id"]>;
        status?: Array<Absence["status"]>;
        type?: Array<NonNullable<Absence["type"]>>;
        usersActive?: boolean;
    };
    scope?: AbsenceScope;
};
export type UsersAccessCustomersProjectsReturnType = UsersAccessCustomersProjects;
export type UsersAccessServicesReturnType = UsersAccessServices;
export type AccessGroupsReturnType = {
    data: Array<AccessGroup>;
};
export type AccessGroupReturnType = {
    data: AccessGroup;
};
export type AggregatesUsersMeReturnType = {
    user: AggregatesUsersMe["user"];
    company: AggregatesUsersMe["company"];
    worktimeRegulation: AggregatesUsersMe["worktimeRegulation"];
};
export type DeleteReturnType = {
    success: boolean;
};
export type CustomerReturnType = {
    data: Customer;
};
export type AddCustomerParams = {
    name: Customer["name"];
    number?: Customer["number"];
    active?: Customer["active"];
    billableDefault?: Customer["billableDefault"] | Billability;
    note?: Customer["note"];
    color?: Customer["color"];
    billServiceId?: Customer["billServiceId"];
};
export type EditCustomerParams = {
    id: Customer["id"];
    name?: Customer["name"];
    number?: Customer["number"];
    active?: Customer["active"];
    billableDefault?: Customer["billableDefault"] | Billability;
    note?: Customer["note"];
    color?: Customer["color"];
    billServiceId?: Customer["billServiceId"];
};
export type DeleteCustomerParams = {
    id: Customer["id"];
    dryRun?: boolean;
    force?: boolean;
};
export type CustomersParams = ParamsWithSort<SortIdNameActive> & {
    filter?: {
        /** Filter customers by active flag */
        active?: boolean;
        /** Filter customers by search term */
        fulltext?: string;
    };
    scope?: CustomerProjectScope;
};
export type CustomersReturnType = ResponseWithPaging & {
    data: Array<Customer>;
};
export type CustomersCountProjectsParams = {
    customersId?: Customer["id"] | Array<Customer["id"]>;
    scope?: CustomerProjectScope;
};
export type CustomersCountProjectsReturnType = ResponseWithPaging & {
    data: Array<CustomerCountProjects>;
};
export type ProjectsParams = ParamsWithSort<SortIdNameActive> & {
    filter?: {
        /** Filter projects by customers id */
        customersId?: number;
        /** Filter projects by active flag */
        active?: boolean;
        /** Filter projects by completed flag */
        completed?: boolean;
        /** Filter projects by search term */
        fulltext?: string;
    };
    scope?: CustomerProjectScope;
};
export type ProjectsReturnType = ResponseWithPaging & {
    data: Array<Project>;
};
export type ProjectReturnType = {
    data: Project;
};
export type ProjectDataReturnType = {
    data: Project;
};
export type ProjectsReportsSortForIndex = "customers_name" | "-customers_name" | "projects_name" | "-projects_name" | "subprojects_name" | "-subprojects_name";
export type ProjectsReportProjectReportItem = {
    customersId: number;
    customersName: string;
    customersNumber: string | null;
    projectsId: number;
    projectsName: string;
    projectsNumber: string | null;
};
export type ProjectsReportRetainerSubprojectReportItem = ProjectsReportProjectReportItem & {
    subprojectsId: number;
    subprojectsName: string;
    subprojectsNumber: string | null;
};
export type ProjectsReportReportItem = ProjectsReportProjectReportItem | ProjectsReportRetainerSubprojectReportItem;
export type ProjectsReportsParams = ParamsWithSort<ProjectsReportsSortForIndex> & {
    filter?: {
        active?: boolean;
        fulltext?: string;
        budgetSource?: Array<0 | 1 | 2 | 3>;
    };
};
export type ProjectsReportsReturnType = ResponseWithPaging & {
    data: Array<ProjectsReportReportItem>;
};
export type SubprojectsParams = ParamsWithSort<SortIdNameActive> & {
    filter?: {
        active?: boolean;
        completed?: boolean;
        fulltext?: string;
        projectsId?: number;
    };
};
export type SubprojectsReturnType = ResponseWithPaging & {
    data: Array<Subproject>;
};
export type SubprojectReturnType = {
    data: Subproject;
};
export type AddProjectParams = {
    name: Project["name"];
    customersId: Project["customersId"];
    active?: Project["active"];
    number?: Project["number"];
    billableDefault?: Project["billableDefault"];
    note?: Project["note"];
    deadline?: Project["deadline"];
    startDate?: Project["startDate"];
    budget?: Project["budget"];
    billServiceId?: Project["billServiceId"];
};
export type AddSubprojectParams = {
    projectsId: Subproject["projectsId"];
    name: Subproject["name"];
    billableDefault?: Subproject["billableDefault"];
    budget?: Subproject["budget"];
    number?: Subproject["number"];
    note?: Subproject["note"];
    startDate?: Subproject["startDate"];
    deadline?: Subproject["deadline"];
    billServiceId?: Subproject["billServiceId"];
};
export type EditProjectParams = {
    id: Project["id"];
    name?: Project["name"];
    customersId?: Project["customersId"];
    active?: Project["active"];
    number?: Project["number"];
    billableDefault?: Project["billableDefault"];
    note?: Project["note"];
    deadline?: Project["deadline"];
    startDate?: Project["startDate"];
    budget?: Project["budget"];
    billServiceId?: Project["billServiceId"];
};
export type EditSubprojectParams = {
    id: Subproject["id"];
    name?: Subproject["name"];
    billableDefault?: Subproject["billableDefault"];
    budget?: Subproject["budget"];
    number?: Subproject["number"];
    note?: Subproject["note"];
    startDate?: Subproject["startDate"];
    deadline?: Subproject["deadline"];
    billServiceId?: Subproject["billServiceId"];
};
export type DeleteProjectParams = {
    id: Project["id"];
    dryRun?: boolean;
    force?: boolean;
};
export type CompleteProjectParams = {
    id: Project["id"];
    completed: Project["completed"];
};
export type SetProjectBilledParams = {
    id: Project["id"];
    billed?: boolean;
    billedMoney?: number | null;
};
export type DeleteSubprojectParams = {
    id: Subproject["id"];
    dryRun?: boolean;
    force?: boolean;
};
export type CompleteSubprojectParams = {
    id: Subproject["id"];
    completed: Subproject["completed"];
};
export type ServiceParams = ParamsWithSort<SortIdNameActive> & {
    filter?: {
        /** Filter service by search term */
        fulltext?: string;
        /** Filter service by active flag */
        active?: boolean;
    };
    scope?: ServiceScope;
};
export type ServiceReturnType = {
    data: Service;
};
export type AddServiceParams = {
    name: Service["name"];
    active?: Service["active"];
    number?: Service["number"];
    note?: Service["note"];
    billServiceId?: Service["billServiceId"];
};
export type EditServiceParams = {
    id: Service["id"];
    name?: Service["name"];
    active?: Service["active"];
    number?: Service["number"];
    note?: Service["note"];
    billServiceId?: Service["billServiceId"];
};
export type DeleteServiceParams = {
    id: Service["id"];
    dryRun?: boolean;
    force?: boolean;
};
export type ServicesReturnType = ResponseWithPaging & {
    data: Array<Service>;
};
export type TeamReturnType = {
    data: Team;
};
export type TeamsReturnType = ResponseWithPaging & {
    data: Array<Team>;
};
export type AddTeamParams = {
    name: Team["name"];
    leader?: Team["leader"];
};
export type EditTeamParams = {
    id: Team["id"];
    name?: Team["name"];
    leader?: Team["leader"];
};
export type TeamsParams = ParamsWithSort<SortIdName> & {
    filter?: {
        /** Filter teams by search term */
        fulltext?: string;
    };
    scope?: UserScope;
};
export type LumpsumServiceParams = ParamsWithSort<SortIdNameActive> & {
    filter?: {
        /** Filter lumpsum service by search term */
        fulltext?: string;
        /** Filter lumpsum service by active flag */
        active?: boolean;
    };
};
export type LumpsumServiceReturnType = {
    data: LumpsumService;
};
export type AddLumpsumServiceParams = {
    name: LumpsumService["name"];
    price: LumpsumService["price"];
    unit?: LumpsumService["unit"];
    active?: LumpsumService["active"];
    number?: LumpsumService["number"];
    note?: LumpsumService["note"];
};
export type EditLumpsumServiceParams = {
    id: LumpsumService["id"];
    name?: LumpsumService["name"];
    price?: LumpsumService["price"];
    unit?: LumpsumService["unit"];
    active?: LumpsumService["active"];
    number?: LumpsumService["number"];
    note?: LumpsumService["note"];
};
export type DeleteLumpsumServiceParams = {
    id: LumpsumService["id"];
    dryRun?: boolean;
    force?: boolean;
};
export type LumpsumServicesReturnType = ResponseWithPaging & {
    data: Array<LumpsumService>;
};
export type UserReturnType = {
    data: User;
};
export type UsersParams = {
    filter?: {
        active?: boolean;
        fulltext?: string;
        teamsId?: Array<null | Team["id"]>;
        scope?: "manageAbsences" | "viewAbsences" | "manage";
    };
    scope?: UserScope;
} & ParamsWithSort<UsersSortForIndex>;
export type AddUserParams = Pick<User, (typeof REQUIRED.ADD_USER)[number]> & Record<string, unknown>;
export type EditUserParams = Pick<User, (typeof REQUIRED.EDIT_USER)[number]> & Record<string, unknown>;
export type UsersReturnType = ResponseWithPaging & {
    data: Array<User>;
};
export type SurchargeModelReturnType = {
    data: SurchargeModel;
};
export type SurchargeModelsReturnType = {
    data: Array<SurchargeModel>;
};
export type EntryReturnType = {
    entry: Entry;
};
export type AddEntryReturnType = {
    entry: Entry;
    stopped?: Entry;
};
export type EditEntryReturnType = {
    entry: Entry;
    running: null | TimeEntry;
};
export type EntriesParams = {
    /** In format ISO 8601 UTC, e.g. "2021-06-30T12:34:56Z" */
    timeSince: string;
    /** In format ISO 8601 UTC, e.g. "2021-06-30T12:34:56Z" */
    timeUntil: string;
    filter?: {
        usersId?: number;
        customersId?: number;
        projectsId?: number;
        servicesId?: number;
        lumpsumServicesId?: number;
        /**
         * 0, 1 or 2 With filter.billable: 2 you only receive entries which are
         * billable AND already billed.
         */
        billable?: Billability;
        text?: string;
        textsId?: number;
        budgetType?: string;
    };
};
export type EntriesReturnType = ResponseWithPaging & ResponseWithFilter<"billable" | "budgetType" | "customersId" | "lumpsumServicesId" | "projectsId" | "servicesId" | "text" | "textsId" | "usersId"> & {
    entries: Array<Entry>;
};
export type EntriesTextsParams = {
    /** Text to search for */
    term: string;
    /** Number of items to return */
    items?: number;
    mode?: EntriesTextsMode;
    filter?: {
        customersId?: number;
        projectsId?: Array<number>;
        servicesId?: Array<number>;
        usersId?: Array<number>;
        billable?: Billability;
        /** In format YYYY-MM-DD */
        timeSince?: string;
        /** In format YYYY-MM-DD */
        timeUntil?: string;
        /** In format YYYY-MM-DD */
        day?: string;
    };
};
/** Can be specified when requesting entries texts */
export declare enum EntriesTextsMode {
    /** Descriptions that exactly match the submitted text (default). */
    ExactMatch = "exact_match",
    /** Descriptions that start with the submitted text fragment. */
    StartsWith = "starts_with",
    /** Descriptions that end with the submitted text fragment. */
    EndsWith = "ends_with",
    /** Descriptions that contain the submitted text fragment. */
    Contains = "contains"
}
/** Can be specified when requesting entries texts */
export declare enum EntriesTextsSort {
    /** Alphabetically ascending (default). */
    TextAsc = "text_asc",
    /** Alphabetically descending. */
    TextDesc = "text_desc",
    /** Chronologically ascending. */
    TimeAsc = "time_asc",
    /** Chronologically descending. */
    TimeDesc = "time_desc"
}
export type EntriesTextsReturnType = {
    data: Array<EntriesText>;
};
export type EntryGroupsReturnType = {
    groups: Array<EntryGroup>;
};
export type EditEntryGroupsReturnType = {
    confirmKey: string;
    affectedEntries: number;
} | {
    success: true;
    editedEntries: number;
};
export type DeleteEntryGroupsReturnType = {
    confirmKey: string;
    affectedEntries: number;
} | {
    success: true;
    deletedEntries: number;
};
export type UserReportReturnType<GivenUserReportType extends UserReportType = UserReportType.Year> = {
    userreport: UserReport<GivenUserReportType>;
};
export type UserReportsReturnType<GivenUserReportType extends UserReportType = UserReportType.Year> = {
    userreports: Array<UserReport<GivenUserReportType>>;
};
export type NonbusinessGroupsReturnType = {
    data: Array<NonbusinessGroup>;
};
export type NonbusinessGroupReturnType = {
    data: NonbusinessGroup;
};
export type AddNonbusinessGroupParams = {
    name: NonbusinessGroup["name"];
    preset?: "";
};
export type EditNonbusinessGroupParams = {
    id: NonbusinessGroup["id"];
    name?: NonbusinessGroup["name"];
};
export type DeleteNonbusinessGroupParams = {
    id: NonbusinessGroup["id"];
};
export type NonbusinessDaysReturnType = {
    data: Array<NonbusinessDay>;
};
export type NonbusinessDayReturnType = {
    data: NonbusinessDay;
};
export type AddNonbusinessDayParams = {
    nonbusinessGroupId: NonbusinessGroup["id"];
    type: NonNullable<NonbusinessDay["type"]>;
    name: NonbusinessDay["name"];
    halfDay?: NonbusinessDay["halfDay"];
    surchargeSpecial?: NonbusinessDay["surchargeSpecial"];
    specialId?: NonbusinessDay["specialId"];
    day?: NonbusinessDay["day"];
    month?: NonbusinessDay["month"];
    year?: NonbusinessDay["year"];
};
export type EditNonbusinessDayParams = {
    id: NonbusinessDay["id"];
    type?: NonNullable<NonbusinessDay["type"]>;
    name?: NonbusinessDay["name"];
    halfDay?: NonbusinessDay["halfDay"];
    surchargeSpecial?: NonbusinessDay["surchargeSpecial"];
    specialId?: NonbusinessDay["specialId"] | null;
    day?: NonbusinessDay["day"] | null;
    month?: NonbusinessDay["month"] | null;
    year?: NonbusinessDay["year"] | null;
};
export type DeleteNonbusinessDayParams = {
    id: NonbusinessDay["id"];
};
export type NonbusinessDaysParams = {
    nonbusinessGroupId?: NonbusinessGroup["id"] | Array<NonbusinessGroup["id"]>;
    year: number;
};
export type UsersNonbusinessDaysParams = {
    filter?: {
        usersId?: User["id"] | Array<User["id"]>;
    };
    year?: number;
};
export type UsersNonbusinessDaysReturnType = ResponseWithPaging & {
    data: Array<UsersNonbusinessDay>;
};
export type UsersNonbusinessGroupsParams = {
    filter?: {
        usersId?: User["id"] | Array<User["id"]>;
        nonbusinessGroupsId?: NonbusinessGroup["id"] | Array<NonbusinessGroup["id"]>;
    };
};
export type UsersNonbusinessGroupsReturnType = ResponseWithPaging & {
    data: Array<UsersNonbusinessGroup>;
};
export type UsersNonbusinessGroupReturnType = {
    data: UsersNonbusinessGroup;
};
export type AddUsersNonbusinessGroupParams = Pick<UsersNonbusinessGroup, "usersId" | "nonbusinessGroupsId" | "dateSince"> & {
    dateUntil?: UsersNonbusinessGroup["dateUntil"];
};
export type EditUsersNonbusinessGroupParams = {
    id: UsersNonbusinessGroup["id"];
} & Partial<Pick<UsersNonbusinessGroup, "usersId" | "nonbusinessGroupsId" | "dateSince" | "dateUntil">>;
export type DeleteUsersNonbusinessGroupParams = {
    id: UsersNonbusinessGroup["id"];
};
export type SubscriptionReturnType = {
    data: Subscription;
};
export type MeReturnType = {
    data: User;
};
export type ClockReturnType = {
    /** The currently running entry */
    running: null | TimeEntry;
    /** Timestamp of the server time. Can be used for clock synchronization */
    currentTime: string;
};
export type ClockStartReturnType = {
    /** The entry that has been started by this call */
    running: TimeEntry;
    /** Returns the previously running entry that has been stopped by this call */
    stopped: null | TimeEntry;
    /**
     * Whether the previously running entry has been truncated to the max length
     * of 23:59:59h
     */
    stoppedHasBeenTruncated: boolean;
    /** Timestamp of the server time. Can be used for clock synchronization */
    currentTime: string;
};
export type ClockStopReturnType = {
    /** The entry that has been stopped by this call */
    stopped: TimeEntry;
    /** Whether the stopped entry has been truncated to the max length of 23:59:59h */
    stoppedHasBeenTruncated: boolean;
    /**
     * The entry that has been started implicitly by this call. Only relevant if
     * the away parameter has been provided.
     */
    running: null | TimeEntry;
    /** Timestamp of the server time. Can be used for clock synchronization */
    currentTime: string;
};
export type ClockEditReturnType = {
    updated: TimeEntry;
    /** The currently running entry */
    running: null | TimeEntry;
    /** Timestamp of the server time. Can be used for clock synchronization */
    currentTime: string;
};
export type RegisterReturnType = {
    success: true;
    user: User;
    apikey: string;
};
export type SearchTextsReturnType = {
    texts: Array<string>;
};
export type TargethoursRowReturnType = {
    targethoursRow: TargethoursRow;
};
export type TargethoursReturnType = {
    targethours: Array<TargethoursRow>;
};
/** Request-only: API uses holiday_fixed_credit (0|1); response has absence_fixed_credit (boolean). */
type TargethourRequestHolidayFixedCredit = {
    holidayFixedCredit?: 0 | 1;
};
export type AddTargethourParams = Required<Pick<TargethoursRowInput, "usersId" | "type" | "dateSince" | "dateUntil" | "compensationMonthly">> & Partial<Omit<TargethoursRowInput, "usersId" | "type" | "dateSince" | "dateUntil" | "compensationMonthly">> & TargethourRequestHolidayFixedCredit;
export type EditTargethourParams = Pick<TargethoursRow, "id"> & Required<Pick<TargethoursRowInput, "type" | "dateSince">> & Partial<Omit<TargethoursRowInput, "type" | "dateSince">> & TargethourRequestHolidayFixedCredit;
export type DeleteTargethourParams = {
    id: TargethoursRow["id"];
};
export type AddUserReturnType = {
    data: User;
};
export type WorkTimesParams = {
    /** The user ID by which the work times should be filtered */
    usersId?: number;
    dateSince: string;
    dateUntil: string;
};
export type WorkTimesReturnType = ResponseWithPaging & {
    workTimeDays: Array<WorkTimeDay>;
};
export type WorkTimesChangeRequestsParams = {
    /** The user ID by which the work time change requests should be filtered */
    usersId?: number;
    dateSince?: string;
    dateUntil?: string;
    status?: WorkTimeChangeRequestStatus;
};
export type WorkTimesChangeRequestsReturnType = ResponseWithPaging & {
    data: Array<WorkTimeChangeRequest>;
};
export type ApproveOrDeclineWorkTimesChangeRequestReturnType = {
    success: boolean;
};
export type AddWorkTimesChangeRequestReturnType = {
    changeRequest: WorkTimeChangeRequest;
    /** Is false if the change request is being returned */
    approvedImmediately: false;
    /**
     * Will be set in case the given work time change request replaced a
     * previous one. This is because on a certain day there can only be one
     * change request per user.
     */
    replacedChangeRequest: null | WorkTimeChangeRequest;
} | {
    /**
     * Is null if the change request was immediately approved (because the
     * rights imply no need for approval)
     */
    changeRequest: null;
    /**
     * Is true if the change request was immediately approved (because the
     * rights imply no need for approval)
     */
    approvedImmediately: true;
    /**
     * Is null if the change request was immediately approved (because the
     * rights imply no need for approval)
     */
    replacedChangeRequest: null;
};
export type AddWorkTimesChangeRequestDataReturnType = {
    data: AddWorkTimesChangeRequestReturnType;
};
export type OvertimecarryRowReturnType = {
    data: Array<OvertimecarryRow>;
};
export type OvertimecarryRowSingleReturnType = {
    data: OvertimecarryRow;
};
export type AddOvertimecarryParams = {
    year: OvertimecarryRow["year"];
    usersId: OvertimecarryRow["usersId"];
    hours: OvertimecarryRow["hours"];
    note?: OvertimecarryRow["note"];
};
export type EditOvertimecarryParams = {
    id: NonNullable<OvertimecarryRow["id"]>;
    year?: OvertimecarryRow["year"];
    hours?: OvertimecarryRow["hours"];
    note?: OvertimecarryRow["note"];
};
export type DeleteOvertimecarryParams = {
    id: NonNullable<OvertimecarryRow["id"]>;
};
export type OvertimecarryRowParams = {
    /** The user ID by which the overtime carry rows should be filtered */
    usersId?: number;
    /** The year to which the data should be restricted to */
    year?: number;
};
export type OvertimeReductionsReturnType = {
    data: Array<OvertimeReduction>;
};
export type OvertimeReductionReturnType = {
    data: OvertimeReduction;
};
export type OvertimeReductionsParams = {
    usersId?: User["id"] | Array<User["id"]>;
};
export type AddOvertimeReductionParams = Pick<OvertimeReduction, "usersId" | "date" | "hours"> & {
    note?: OvertimeReduction["note"];
};
export type EditOvertimeReductionParams = {
    id: OvertimeReduction["id"];
} & Partial<Pick<OvertimeReduction, "date" | "hours" | "note">>;
export type DeleteOvertimeReductionParams = {
    id: OvertimeReduction["id"];
};
export type HolidaysQuotasReturnType = {
    data: Array<HolidaysQuota>;
};
export type HolidaysQuotaReturnType = {
    data: HolidaysQuota;
};
export type AddHolidaysQuotaParams = {
    usersId: HolidaysQuota["usersId"];
    yearSince: HolidaysQuota["yearSince"];
    yearUntil?: HolidaysQuota["yearUntil"];
    count: HolidaysQuota["count"];
    note?: HolidaysQuota["note"];
};
export type EditHolidaysQuotaParams = {
    id: HolidaysQuota["id"];
    yearSince?: HolidaysQuota["yearSince"];
    yearUntil?: HolidaysQuota["yearUntil"];
    count?: HolidaysQuota["count"];
    note?: HolidaysQuota["note"];
};
export type DeleteHolidaysQuotaParams = {
    id: HolidaysQuota["id"];
};
export type HolidaysQuotasParams = {
    /** The user ID by which the holidays quota rows should be filtered */
    usersId?: number;
    year?: number;
};
export type HolidaysCarryoversReturnType = {
    data: Array<HolidaysCarryover>;
};
export type HolidaysCarryoverReturnType = {
    data: HolidaysCarryover;
};
export type AddHolidaysCarryoverParams = {
    year: HolidaysCarryover["year"];
    usersId: HolidaysCarryover["usersId"];
    count: HolidaysCarryover["count"];
    note?: HolidaysCarryover["note"];
};
export type EditHolidaysCarryoverParams = {
    id: NonNullable<HolidaysCarryover["id"]>;
    year?: HolidaysCarryover["year"];
    count?: HolidaysCarryover["count"];
    note?: HolidaysCarryover["note"];
};
export type DeleteHolidaysCarryoverParams = {
    id: NonNullable<HolidaysCarryover["id"]>;
};
export type HolidaysCarryoversParams = {
    /** The user ID by which the holidays carry rows should be filtered */
    usersId?: number;
    /** The year to which the data should be restricted to */
    year?: number;
};
export {};
//# sourceMappingURL=clockodo.d.ts.map