payrollUKApi.ts

/**
 * Xero Payroll UK
 * This is the Xero Payroll API for orgs in the UK region.
 *
 * The version of the OpenAPI document: 9.1.1
 * Contact: api@xero.com
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * https://openapi-generator.tech
 * Do not edit the class manually.
 */

import http = require('http');
import fs = require('fs');

/* tslint:disable:no-unused-locals */
import { Benefit } from '../model/payroll-uk/benefit';
import { BenefitObject } from '../model/payroll-uk/benefitObject';
import { Benefits } from '../model/payroll-uk/benefits';
import { Deduction } from '../model/payroll-uk/deduction';
import { DeductionObject } from '../model/payroll-uk/deductionObject';
import { Deductions } from '../model/payroll-uk/deductions';
import { EarningsOrderObject } from '../model/payroll-uk/earningsOrderObject';
import { EarningsOrders } from '../model/payroll-uk/earningsOrders';
import { EarningsRate } from '../model/payroll-uk/earningsRate';
import { EarningsRateObject } from '../model/payroll-uk/earningsRateObject';
import { EarningsRates } from '../model/payroll-uk/earningsRates';
import { EarningsTemplate } from '../model/payroll-uk/earningsTemplate';
import { EarningsTemplateObject } from '../model/payroll-uk/earningsTemplateObject';
import { Employee } from '../model/payroll-uk/employee';
import { EmployeeLeave } from '../model/payroll-uk/employeeLeave';
import { EmployeeLeaveBalances } from '../model/payroll-uk/employeeLeaveBalances';
import { EmployeeLeaveObject } from '../model/payroll-uk/employeeLeaveObject';
import { EmployeeLeaveType } from '../model/payroll-uk/employeeLeaveType';
import { EmployeeLeaveTypeObject } from '../model/payroll-uk/employeeLeaveTypeObject';
import { EmployeeLeaveTypes } from '../model/payroll-uk/employeeLeaveTypes';
import { EmployeeLeaves } from '../model/payroll-uk/employeeLeaves';
import { EmployeeObject } from '../model/payroll-uk/employeeObject';
import { EmployeeOpeningBalances } from '../model/payroll-uk/employeeOpeningBalances';
import { EmployeeOpeningBalancesObject } from '../model/payroll-uk/employeeOpeningBalancesObject';
import { EmployeePayTemplateObject } from '../model/payroll-uk/employeePayTemplateObject';
import { EmployeePayTemplates } from '../model/payroll-uk/employeePayTemplates';
import { EmployeeStatutoryLeaveBalanceObject } from '../model/payroll-uk/employeeStatutoryLeaveBalanceObject';
import { EmployeeStatutoryLeavesSummaries } from '../model/payroll-uk/employeeStatutoryLeavesSummaries';
import { EmployeeStatutorySickLeave } from '../model/payroll-uk/employeeStatutorySickLeave';
import { EmployeeStatutorySickLeaveObject } from '../model/payroll-uk/employeeStatutorySickLeaveObject';
import { EmployeeTaxObject } from '../model/payroll-uk/employeeTaxObject';
import { Employees } from '../model/payroll-uk/employees';
import { Employment } from '../model/payroll-uk/employment';
import { EmploymentObject } from '../model/payroll-uk/employmentObject';
import { LeavePeriods } from '../model/payroll-uk/leavePeriods';
import { LeaveType } from '../model/payroll-uk/leaveType';
import { LeaveTypeObject } from '../model/payroll-uk/leaveTypeObject';
import { LeaveTypes } from '../model/payroll-uk/leaveTypes';
import { PayRun } from '../model/payroll-uk/payRun';
import { PayRunCalendar } from '../model/payroll-uk/payRunCalendar';
import { PayRunCalendarObject } from '../model/payroll-uk/payRunCalendarObject';
import { PayRunCalendars } from '../model/payroll-uk/payRunCalendars';
import { PayRunObject } from '../model/payroll-uk/payRunObject';
import { PayRuns } from '../model/payroll-uk/payRuns';
import { PaymentMethod } from '../model/payroll-uk/paymentMethod';
import { PaymentMethodObject } from '../model/payroll-uk/paymentMethodObject';
import { PayslipObject } from '../model/payroll-uk/payslipObject';
import { Payslips } from '../model/payroll-uk/payslips';
import { Problem } from '../model/payroll-uk/problem';
import { Reimbursement } from '../model/payroll-uk/reimbursement';
import { ReimbursementObject } from '../model/payroll-uk/reimbursementObject';
import { Reimbursements } from '../model/payroll-uk/reimbursements';
import { SalaryAndWage } from '../model/payroll-uk/salaryAndWage';
import { SalaryAndWageObject } from '../model/payroll-uk/salaryAndWageObject';
import { SalaryAndWages } from '../model/payroll-uk/salaryAndWages';
import { Settings } from '../model/payroll-uk/settings';
import { Timesheet } from '../model/payroll-uk/timesheet';
import { TimesheetLine } from '../model/payroll-uk/timesheetLine';
import { TimesheetLineObject } from '../model/payroll-uk/timesheetLineObject';
import { TimesheetObject } from '../model/payroll-uk/timesheetObject';
import { Timesheets } from '../model/payroll-uk/timesheets';
import { TrackingCategories } from '../model/payroll-uk/trackingCategories';

import { ObjectSerializer, Authentication, VoidAuth } from '../model/payroll-uk/models';
import { ApiError } from '../../model/ApiError';
import axios, { AxiosRequestConfig, AxiosResponse } from 'axios';
import { Readable } from "stream";
import { OAuth } from '../model/payroll-uk/models';

let defaultBasePath = 'https://api.xero.com/payroll.xro/2.0';

// ===============================================
// This file is autogenerated - Please do not edit
// ===============================================

export enum PayrollUkApiApiKeys {
}

export class PayrollUkApi {
    protected _basePath = defaultBasePath;
    protected defaultHeaders : any = {'user-agent': 'xero-node-13.1.0'};
    protected _useQuerystring : boolean = false;
    protected binaryHeaders : any = {};

    protected authentications = {
        'default': <Authentication>new VoidAuth(),
        'OAuth2': new OAuth(),
    }

    constructor(basePath?: string);
    constructor(basePathOrUsername: string, password?: string, basePath?: string) {
        if (password) {
            if (basePath) {
                this.basePath = basePath;
            }
        } else {
            if (basePathOrUsername) {
                this.basePath = basePathOrUsername
            }
        }
    }

    set useQuerystring(value: boolean) {
        this._useQuerystring = value;
    }

    set basePath(basePath: string) {
        this._basePath = basePath;
    }

    get basePath() {
        return this._basePath;
    }

    public setDefaultAuthentication(auth: Authentication) {
        this.authentications.default = auth;
    }

    public setApiKey(key: PayrollUkApiApiKeys, value: string) {
        (this.authentications as any)[PayrollUkApiApiKeys[key]].apiKey = value;
    }

    set accessToken(token: string) {
        this.authentications.OAuth2.accessToken = token;
    }

    /**
     * 
     * @summary Approves a specific timesheet
     * @param xeroTenantId Xero identifier for Tenant
     * @param timesheetID Identifier for the timesheet
     * @param idempotencyKey This allows you to safely retry requests without the risk of duplicate processing. 128 character max.
     */     
    public async approveTimesheet (xeroTenantId: string, timesheetID: string, idempotencyKey?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: TimesheetObject;  }> {
        const localVarPath = this.basePath + '/Timesheets/{TimesheetID}/Approve'
            .replace('{' + 'TimesheetID' + '}', encodeURIComponent(String(timesheetID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling approveTimesheet.');
        }

        // verify required parameter 'timesheetID' is not null or undefined
        if (timesheetID === null || timesheetID === undefined) {
            throw new Error('Required parameter timesheetID was null or undefined when calling approveTimesheet.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Idempotency-Key'] = ObjectSerializer.serialize(idempotencyKey, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'POST',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: TimesheetObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "TimesheetObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Creates a new employee benefit
     * @param xeroTenantId Xero identifier for Tenant
     * @param benefit 
     * @param idempotencyKey This allows you to safely retry requests without the risk of duplicate processing. 128 character max.
     */     
    public async createBenefit (xeroTenantId: string, benefit: Benefit, idempotencyKey?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: BenefitObject;  }> {
        const localVarPath = this.basePath + '/Benefits';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling createBenefit.');
        }

        // verify required parameter 'benefit' is not null or undefined
        if (benefit === null || benefit === undefined) {
            throw new Error('Required parameter benefit was null or undefined when calling createBenefit.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Idempotency-Key'] = ObjectSerializer.serialize(idempotencyKey, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'POST',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: ObjectSerializer.serialize(benefit, "Benefit"),
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: BenefitObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "BenefitObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Creates a new deduction
     * @param xeroTenantId Xero identifier for Tenant
     * @param deduction 
     * @param idempotencyKey This allows you to safely retry requests without the risk of duplicate processing. 128 character max.
     */     
    public async createDeduction (xeroTenantId: string, deduction: Deduction, idempotencyKey?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: DeductionObject;  }> {
        const localVarPath = this.basePath + '/Deductions';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling createDeduction.');
        }

        // verify required parameter 'deduction' is not null or undefined
        if (deduction === null || deduction === undefined) {
            throw new Error('Required parameter deduction was null or undefined when calling createDeduction.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Idempotency-Key'] = ObjectSerializer.serialize(idempotencyKey, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'POST',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: ObjectSerializer.serialize(deduction, "Deduction"),
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: DeductionObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "DeductionObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Creates a new earnings rate
     * @param xeroTenantId Xero identifier for Tenant
     * @param earningsRate 
     * @param idempotencyKey This allows you to safely retry requests without the risk of duplicate processing. 128 character max.
     */     
    public async createEarningsRate (xeroTenantId: string, earningsRate: EarningsRate, idempotencyKey?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EarningsRateObject;  }> {
        const localVarPath = this.basePath + '/EarningsRates';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling createEarningsRate.');
        }

        // verify required parameter 'earningsRate' is not null or undefined
        if (earningsRate === null || earningsRate === undefined) {
            throw new Error('Required parameter earningsRate was null or undefined when calling createEarningsRate.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Idempotency-Key'] = ObjectSerializer.serialize(idempotencyKey, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'POST',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: ObjectSerializer.serialize(earningsRate, "EarningsRate"),
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EarningsRateObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EarningsRateObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Creates employees
     * @param xeroTenantId Xero identifier for Tenant
     * @param employee 
     * @param idempotencyKey This allows you to safely retry requests without the risk of duplicate processing. 128 character max.
     */     
    public async createEmployee (xeroTenantId: string, employee: Employee, idempotencyKey?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EmployeeObject;  }> {
        const localVarPath = this.basePath + '/Employees';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling createEmployee.');
        }

        // verify required parameter 'employee' is not null or undefined
        if (employee === null || employee === undefined) {
            throw new Error('Required parameter employee was null or undefined when calling createEmployee.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Idempotency-Key'] = ObjectSerializer.serialize(idempotencyKey, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'POST',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: ObjectSerializer.serialize(employee, "Employee"),
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EmployeeObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EmployeeObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Creates an earnings template records for a specific employee
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     * @param earningsTemplate 
     * @param idempotencyKey This allows you to safely retry requests without the risk of duplicate processing. 128 character max.
     */     
    public async createEmployeeEarningsTemplate (xeroTenantId: string, employeeID: string, earningsTemplate: EarningsTemplate, idempotencyKey?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EarningsTemplateObject;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}/PayTemplates/earnings'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling createEmployeeEarningsTemplate.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling createEmployeeEarningsTemplate.');
        }

        // verify required parameter 'earningsTemplate' is not null or undefined
        if (earningsTemplate === null || earningsTemplate === undefined) {
            throw new Error('Required parameter earningsTemplate was null or undefined when calling createEmployeeEarningsTemplate.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Idempotency-Key'] = ObjectSerializer.serialize(idempotencyKey, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'POST',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: ObjectSerializer.serialize(earningsTemplate, "EarningsTemplate"),
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EarningsTemplateObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EarningsTemplateObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Creates leave records for a specific employee
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     * @param employeeLeave 
     * @param idempotencyKey This allows you to safely retry requests without the risk of duplicate processing. 128 character max.
     */     
    public async createEmployeeLeave (xeroTenantId: string, employeeID: string, employeeLeave: EmployeeLeave, idempotencyKey?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EmployeeLeaveObject;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}/Leave'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling createEmployeeLeave.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling createEmployeeLeave.');
        }

        // verify required parameter 'employeeLeave' is not null or undefined
        if (employeeLeave === null || employeeLeave === undefined) {
            throw new Error('Required parameter employeeLeave was null or undefined when calling createEmployeeLeave.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Idempotency-Key'] = ObjectSerializer.serialize(idempotencyKey, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'POST',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: ObjectSerializer.serialize(employeeLeave, "EmployeeLeave"),
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EmployeeLeaveObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EmployeeLeaveObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Creates employee leave type records
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     * @param employeeLeaveType 
     * @param idempotencyKey This allows you to safely retry requests without the risk of duplicate processing. 128 character max.
     */     
    public async createEmployeeLeaveType (xeroTenantId: string, employeeID: string, employeeLeaveType: EmployeeLeaveType, idempotencyKey?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EmployeeLeaveTypeObject;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}/LeaveTypes'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling createEmployeeLeaveType.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling createEmployeeLeaveType.');
        }

        // verify required parameter 'employeeLeaveType' is not null or undefined
        if (employeeLeaveType === null || employeeLeaveType === undefined) {
            throw new Error('Required parameter employeeLeaveType was null or undefined when calling createEmployeeLeaveType.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Idempotency-Key'] = ObjectSerializer.serialize(idempotencyKey, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'POST',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: ObjectSerializer.serialize(employeeLeaveType, "EmployeeLeaveType"),
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EmployeeLeaveTypeObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EmployeeLeaveTypeObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Creates an opening balance for a specific employee
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     * @param employeeOpeningBalances 
     * @param idempotencyKey This allows you to safely retry requests without the risk of duplicate processing. 128 character max.
     */     
    public async createEmployeeOpeningBalances (xeroTenantId: string, employeeID: string, employeeOpeningBalances: EmployeeOpeningBalances, idempotencyKey?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EmployeeOpeningBalancesObject;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}/ukopeningbalances'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling createEmployeeOpeningBalances.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling createEmployeeOpeningBalances.');
        }

        // verify required parameter 'employeeOpeningBalances' is not null or undefined
        if (employeeOpeningBalances === null || employeeOpeningBalances === undefined) {
            throw new Error('Required parameter employeeOpeningBalances was null or undefined when calling createEmployeeOpeningBalances.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Idempotency-Key'] = ObjectSerializer.serialize(idempotencyKey, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'POST',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: ObjectSerializer.serialize(employeeOpeningBalances, "EmployeeOpeningBalances"),
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EmployeeOpeningBalancesObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EmployeeOpeningBalancesObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Creates an employee payment method
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     * @param paymentMethod 
     * @param idempotencyKey This allows you to safely retry requests without the risk of duplicate processing. 128 character max.
     */     
    public async createEmployeePaymentMethod (xeroTenantId: string, employeeID: string, paymentMethod: PaymentMethod, idempotencyKey?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: PaymentMethodObject;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}/PaymentMethods'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling createEmployeePaymentMethod.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling createEmployeePaymentMethod.');
        }

        // verify required parameter 'paymentMethod' is not null or undefined
        if (paymentMethod === null || paymentMethod === undefined) {
            throw new Error('Required parameter paymentMethod was null or undefined when calling createEmployeePaymentMethod.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Idempotency-Key'] = ObjectSerializer.serialize(idempotencyKey, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'POST',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: ObjectSerializer.serialize(paymentMethod, "PaymentMethod"),
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: PaymentMethodObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "PaymentMethodObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Creates a salary and wage record for a specific employee
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     * @param salaryAndWage 
     * @param idempotencyKey This allows you to safely retry requests without the risk of duplicate processing. 128 character max.
     */     
    public async createEmployeeSalaryAndWage (xeroTenantId: string, employeeID: string, salaryAndWage: SalaryAndWage, idempotencyKey?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: SalaryAndWageObject;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}/SalaryAndWages'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling createEmployeeSalaryAndWage.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling createEmployeeSalaryAndWage.');
        }

        // verify required parameter 'salaryAndWage' is not null or undefined
        if (salaryAndWage === null || salaryAndWage === undefined) {
            throw new Error('Required parameter salaryAndWage was null or undefined when calling createEmployeeSalaryAndWage.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Idempotency-Key'] = ObjectSerializer.serialize(idempotencyKey, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'POST',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: ObjectSerializer.serialize(salaryAndWage, "SalaryAndWage"),
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: SalaryAndWageObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "SalaryAndWageObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Creates statutory sick leave records
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeStatutorySickLeave 
     * @param idempotencyKey This allows you to safely retry requests without the risk of duplicate processing. 128 character max.
     */     
    public async createEmployeeStatutorySickLeave (xeroTenantId: string, employeeStatutorySickLeave: EmployeeStatutorySickLeave, idempotencyKey?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EmployeeStatutorySickLeaveObject;  }> {
        const localVarPath = this.basePath + '/StatutoryLeaves/Sick';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling createEmployeeStatutorySickLeave.');
        }

        // verify required parameter 'employeeStatutorySickLeave' is not null or undefined
        if (employeeStatutorySickLeave === null || employeeStatutorySickLeave === undefined) {
            throw new Error('Required parameter employeeStatutorySickLeave was null or undefined when calling createEmployeeStatutorySickLeave.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Idempotency-Key'] = ObjectSerializer.serialize(idempotencyKey, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'POST',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: ObjectSerializer.serialize(employeeStatutorySickLeave, "EmployeeStatutorySickLeave"),
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EmployeeStatutorySickLeaveObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EmployeeStatutorySickLeaveObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Creates employment detail for a specific employee using a unique employee ID
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     * @param employment 
     * @param idempotencyKey This allows you to safely retry requests without the risk of duplicate processing. 128 character max.
     */     
    public async createEmployment (xeroTenantId: string, employeeID: string, employment: Employment, idempotencyKey?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EmploymentObject;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}/Employment'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling createEmployment.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling createEmployment.');
        }

        // verify required parameter 'employment' is not null or undefined
        if (employment === null || employment === undefined) {
            throw new Error('Required parameter employment was null or undefined when calling createEmployment.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Idempotency-Key'] = ObjectSerializer.serialize(idempotencyKey, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'POST',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: ObjectSerializer.serialize(employment, "Employment"),
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EmploymentObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EmploymentObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Creates a new leave type
     * @param xeroTenantId Xero identifier for Tenant
     * @param leaveType 
     * @param idempotencyKey This allows you to safely retry requests without the risk of duplicate processing. 128 character max.
     */     
    public async createLeaveType (xeroTenantId: string, leaveType: LeaveType, idempotencyKey?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: LeaveTypeObject;  }> {
        const localVarPath = this.basePath + '/LeaveTypes';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling createLeaveType.');
        }

        // verify required parameter 'leaveType' is not null or undefined
        if (leaveType === null || leaveType === undefined) {
            throw new Error('Required parameter leaveType was null or undefined when calling createLeaveType.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Idempotency-Key'] = ObjectSerializer.serialize(idempotencyKey, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'POST',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: ObjectSerializer.serialize(leaveType, "LeaveType"),
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: LeaveTypeObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "LeaveTypeObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Creates multiple earnings template records for a specific employee using a unique employee ID
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     * @param earningsTemplate 
     * @param idempotencyKey This allows you to safely retry requests without the risk of duplicate processing. 128 character max.
     */     
    public async createMultipleEmployeeEarningsTemplate (xeroTenantId: string, employeeID: string, earningsTemplate: Array<EarningsTemplate>, idempotencyKey?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EmployeePayTemplates;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}/paytemplateearnings'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling createMultipleEmployeeEarningsTemplate.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling createMultipleEmployeeEarningsTemplate.');
        }

        // verify required parameter 'earningsTemplate' is not null or undefined
        if (earningsTemplate === null || earningsTemplate === undefined) {
            throw new Error('Required parameter earningsTemplate was null or undefined when calling createMultipleEmployeeEarningsTemplate.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Idempotency-Key'] = ObjectSerializer.serialize(idempotencyKey, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'POST',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: ObjectSerializer.serialize(earningsTemplate, "Array<EarningsTemplate>"),
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EmployeePayTemplates;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EmployeePayTemplates");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Creates a new payrun calendar
     * @param xeroTenantId Xero identifier for Tenant
     * @param payRunCalendar 
     * @param idempotencyKey This allows you to safely retry requests without the risk of duplicate processing. 128 character max.
     */     
    public async createPayRunCalendar (xeroTenantId: string, payRunCalendar: PayRunCalendar, idempotencyKey?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: PayRunCalendarObject;  }> {
        const localVarPath = this.basePath + '/PayRunCalendars';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling createPayRunCalendar.');
        }

        // verify required parameter 'payRunCalendar' is not null or undefined
        if (payRunCalendar === null || payRunCalendar === undefined) {
            throw new Error('Required parameter payRunCalendar was null or undefined when calling createPayRunCalendar.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Idempotency-Key'] = ObjectSerializer.serialize(idempotencyKey, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'POST',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: ObjectSerializer.serialize(payRunCalendar, "PayRunCalendar"),
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: PayRunCalendarObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "PayRunCalendarObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Creates a new reimbursement
     * @param xeroTenantId Xero identifier for Tenant
     * @param reimbursement 
     * @param idempotencyKey This allows you to safely retry requests without the risk of duplicate processing. 128 character max.
     */     
    public async createReimbursement (xeroTenantId: string, reimbursement: Reimbursement, idempotencyKey?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: ReimbursementObject;  }> {
        const localVarPath = this.basePath + '/Reimbursements';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling createReimbursement.');
        }

        // verify required parameter 'reimbursement' is not null or undefined
        if (reimbursement === null || reimbursement === undefined) {
            throw new Error('Required parameter reimbursement was null or undefined when calling createReimbursement.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Idempotency-Key'] = ObjectSerializer.serialize(idempotencyKey, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'POST',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: ObjectSerializer.serialize(reimbursement, "Reimbursement"),
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: ReimbursementObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "ReimbursementObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Creates a new timesheet
     * @param xeroTenantId Xero identifier for Tenant
     * @param timesheet 
     * @param idempotencyKey This allows you to safely retry requests without the risk of duplicate processing. 128 character max.
     */     
    public async createTimesheet (xeroTenantId: string, timesheet: Timesheet, idempotencyKey?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: TimesheetObject;  }> {
        const localVarPath = this.basePath + '/Timesheets';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling createTimesheet.');
        }

        // verify required parameter 'timesheet' is not null or undefined
        if (timesheet === null || timesheet === undefined) {
            throw new Error('Required parameter timesheet was null or undefined when calling createTimesheet.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Idempotency-Key'] = ObjectSerializer.serialize(idempotencyKey, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'POST',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: ObjectSerializer.serialize(timesheet, "Timesheet"),
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: TimesheetObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "TimesheetObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Creates a new timesheet line for a specific timesheet using a unique timesheet ID
     * @param xeroTenantId Xero identifier for Tenant
     * @param timesheetID Identifier for the timesheet
     * @param timesheetLine 
     * @param idempotencyKey This allows you to safely retry requests without the risk of duplicate processing. 128 character max.
     */     
    public async createTimesheetLine (xeroTenantId: string, timesheetID: string, timesheetLine: TimesheetLine, idempotencyKey?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: TimesheetLineObject;  }> {
        const localVarPath = this.basePath + '/Timesheets/{TimesheetID}/Lines'
            .replace('{' + 'TimesheetID' + '}', encodeURIComponent(String(timesheetID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling createTimesheetLine.');
        }

        // verify required parameter 'timesheetID' is not null or undefined
        if (timesheetID === null || timesheetID === undefined) {
            throw new Error('Required parameter timesheetID was null or undefined when calling createTimesheetLine.');
        }

        // verify required parameter 'timesheetLine' is not null or undefined
        if (timesheetLine === null || timesheetLine === undefined) {
            throw new Error('Required parameter timesheetLine was null or undefined when calling createTimesheetLine.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Idempotency-Key'] = ObjectSerializer.serialize(idempotencyKey, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'POST',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: ObjectSerializer.serialize(timesheetLine, "TimesheetLine"),
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: TimesheetLineObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "TimesheetLineObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Deletes a specific employee\'s earnings template record
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     * @param payTemplateEarningID Id for single pay template earnings object
     */     
    public async deleteEmployeeEarningsTemplate (xeroTenantId: string, employeeID: string, payTemplateEarningID: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body?: any;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}/PayTemplates/earnings/{PayTemplateEarningID}'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)))
            .replace('{' + 'PayTemplateEarningID' + '}', encodeURIComponent(String(payTemplateEarningID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling deleteEmployeeEarningsTemplate.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling deleteEmployeeEarningsTemplate.');
        }

        // verify required parameter 'payTemplateEarningID' is not null or undefined
        if (payTemplateEarningID === null || payTemplateEarningID === undefined) {
            throw new Error('Required parameter payTemplateEarningID was null or undefined when calling deleteEmployeeEarningsTemplate.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'DELETE',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body?: any;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)

                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Deletes a specific employee\'s leave record
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     * @param leaveID Leave id for single object
     */     
    public async deleteEmployeeLeave (xeroTenantId: string, employeeID: string, leaveID: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EmployeeLeaveObject;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}/Leave/{LeaveID}'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)))
            .replace('{' + 'LeaveID' + '}', encodeURIComponent(String(leaveID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling deleteEmployeeLeave.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling deleteEmployeeLeave.');
        }

        // verify required parameter 'leaveID' is not null or undefined
        if (leaveID === null || leaveID === undefined) {
            throw new Error('Required parameter leaveID was null or undefined when calling deleteEmployeeLeave.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'DELETE',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EmployeeLeaveObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EmployeeLeaveObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Deletes a salary and wages record for a specific employee
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     * @param salaryAndWagesID Id for single salary and wages object
     */     
    public async deleteEmployeeSalaryAndWage (xeroTenantId: string, employeeID: string, salaryAndWagesID: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body?: any;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}/SalaryAndWages/{SalaryAndWagesID}'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)))
            .replace('{' + 'SalaryAndWagesID' + '}', encodeURIComponent(String(salaryAndWagesID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling deleteEmployeeSalaryAndWage.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling deleteEmployeeSalaryAndWage.');
        }

        // verify required parameter 'salaryAndWagesID' is not null or undefined
        if (salaryAndWagesID === null || salaryAndWagesID === undefined) {
            throw new Error('Required parameter salaryAndWagesID was null or undefined when calling deleteEmployeeSalaryAndWage.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'DELETE',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body?: any;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)

                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Deletes a specific timesheet
     * @param xeroTenantId Xero identifier for Tenant
     * @param timesheetID Identifier for the timesheet
     */     
    public async deleteTimesheet (xeroTenantId: string, timesheetID: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: TimesheetLine;  }> {
        const localVarPath = this.basePath + '/Timesheets/{TimesheetID}'
            .replace('{' + 'TimesheetID' + '}', encodeURIComponent(String(timesheetID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling deleteTimesheet.');
        }

        // verify required parameter 'timesheetID' is not null or undefined
        if (timesheetID === null || timesheetID === undefined) {
            throw new Error('Required parameter timesheetID was null or undefined when calling deleteTimesheet.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'DELETE',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: TimesheetLine;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "TimesheetLine");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Deletes a specific timesheet line
     * @param xeroTenantId Xero identifier for Tenant
     * @param timesheetID Identifier for the timesheet
     * @param timesheetLineID Identifier for the timesheet line
     */     
    public async deleteTimesheetLine (xeroTenantId: string, timesheetID: string, timesheetLineID: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: TimesheetLine;  }> {
        const localVarPath = this.basePath + '/Timesheets/{TimesheetID}/Lines/{TimesheetLineID}'
            .replace('{' + 'TimesheetID' + '}', encodeURIComponent(String(timesheetID)))
            .replace('{' + 'TimesheetLineID' + '}', encodeURIComponent(String(timesheetLineID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling deleteTimesheetLine.');
        }

        // verify required parameter 'timesheetID' is not null or undefined
        if (timesheetID === null || timesheetID === undefined) {
            throw new Error('Required parameter timesheetID was null or undefined when calling deleteTimesheetLine.');
        }

        // verify required parameter 'timesheetLineID' is not null or undefined
        if (timesheetLineID === null || timesheetLineID === undefined) {
            throw new Error('Required parameter timesheetLineID was null or undefined when calling deleteTimesheetLine.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'DELETE',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: TimesheetLine;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "TimesheetLine");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves a specific benefit by using a unique benefit ID
     * @param xeroTenantId Xero identifier for Tenant
     * @param id Identifier for the benefit
     */     
    public async getBenefit (xeroTenantId: string, id: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: BenefitObject;  }> {
        const localVarPath = this.basePath + '/Benefits/{id}'
            .replace('{' + 'id' + '}', encodeURIComponent(String(id)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getBenefit.');
        }

        // verify required parameter 'id' is not null or undefined
        if (id === null || id === undefined) {
            throw new Error('Required parameter id was null or undefined when calling getBenefit.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: BenefitObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "BenefitObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves employee benefits
     * @param xeroTenantId Xero identifier for Tenant
     * @param page Page number which specifies the set of records to retrieve. By default the number of the records per set is 100.
     */     
    public async getBenefits (xeroTenantId: string, page?: number, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: Benefits;  }> {
        const localVarPath = this.basePath + '/Benefits';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getBenefits.');
        }

        if (page !== undefined) {
            localVarQueryParameters['page'] = ObjectSerializer.serialize(page, "number");
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: Benefits;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "Benefits");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves a specific deduction by using a unique deduction ID
     * @param xeroTenantId Xero identifier for Tenant
     * @param deductionId Identifier for the deduction
     */     
    public async getDeduction (xeroTenantId: string, deductionId: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: DeductionObject;  }> {
        const localVarPath = this.basePath + '/Deductions/{deductionId}'
            .replace('{' + 'deductionId' + '}', encodeURIComponent(String(deductionId)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getDeduction.');
        }

        // verify required parameter 'deductionId' is not null or undefined
        if (deductionId === null || deductionId === undefined) {
            throw new Error('Required parameter deductionId was null or undefined when calling getDeduction.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: DeductionObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "DeductionObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves deductions
     * @param xeroTenantId Xero identifier for Tenant
     * @param page Page number which specifies the set of records to retrieve. By default the number of the records per set is 100.
     */     
    public async getDeductions (xeroTenantId: string, page?: number, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: Deductions;  }> {
        const localVarPath = this.basePath + '/Deductions';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getDeductions.');
        }

        if (page !== undefined) {
            localVarQueryParameters['page'] = ObjectSerializer.serialize(page, "number");
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: Deductions;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "Deductions");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves a specific earnings orders by using a unique earnings orders id
     * @param xeroTenantId Xero identifier for Tenant
     * @param id Identifier for the deduction
     */     
    public async getEarningsOrder (xeroTenantId: string, id: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EarningsOrderObject;  }> {
        const localVarPath = this.basePath + '/EarningsOrders/{id}'
            .replace('{' + 'id' + '}', encodeURIComponent(String(id)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getEarningsOrder.');
        }

        // verify required parameter 'id' is not null or undefined
        if (id === null || id === undefined) {
            throw new Error('Required parameter id was null or undefined when calling getEarningsOrder.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EarningsOrderObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EarningsOrderObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves earnings orders
     * @param xeroTenantId Xero identifier for Tenant
     * @param page Page number which specifies the set of records to retrieve. By default the number of the records per set is 100.
     */     
    public async getEarningsOrders (xeroTenantId: string, page?: number, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EarningsOrders;  }> {
        const localVarPath = this.basePath + '/EarningsOrders';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getEarningsOrders.');
        }

        if (page !== undefined) {
            localVarQueryParameters['page'] = ObjectSerializer.serialize(page, "number");
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EarningsOrders;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EarningsOrders");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves a specific earnings rates by using a unique earnings rate id
     * @param xeroTenantId Xero identifier for Tenant
     * @param earningsRateID Identifier for the earnings rate
     */     
    public async getEarningsRate (xeroTenantId: string, earningsRateID: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EarningsRateObject;  }> {
        const localVarPath = this.basePath + '/EarningsRates/{EarningsRateID}'
            .replace('{' + 'EarningsRateID' + '}', encodeURIComponent(String(earningsRateID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getEarningsRate.');
        }

        // verify required parameter 'earningsRateID' is not null or undefined
        if (earningsRateID === null || earningsRateID === undefined) {
            throw new Error('Required parameter earningsRateID was null or undefined when calling getEarningsRate.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EarningsRateObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EarningsRateObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves earnings rates
     * @param xeroTenantId Xero identifier for Tenant
     * @param page Page number which specifies the set of records to retrieve. By default the number of the records per set is 100.
     */     
    public async getEarningsRates (xeroTenantId: string, page?: number, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EarningsRates;  }> {
        const localVarPath = this.basePath + '/EarningsRates';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getEarningsRates.');
        }

        if (page !== undefined) {
            localVarQueryParameters['page'] = ObjectSerializer.serialize(page, "number");
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EarningsRates;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EarningsRates");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves specific employees by using a unique employee ID
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     */     
    public async getEmployee (xeroTenantId: string, employeeID: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EmployeeObject;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getEmployee.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling getEmployee.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EmployeeObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EmployeeObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves a specific employee\'s leave record using a unique employee ID
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     * @param leaveID Leave id for single object
     */     
    public async getEmployeeLeave (xeroTenantId: string, employeeID: string, leaveID: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EmployeeLeaveObject;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}/Leave/{LeaveID}'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)))
            .replace('{' + 'LeaveID' + '}', encodeURIComponent(String(leaveID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getEmployeeLeave.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling getEmployeeLeave.');
        }

        // verify required parameter 'leaveID' is not null or undefined
        if (leaveID === null || leaveID === undefined) {
            throw new Error('Required parameter leaveID was null or undefined when calling getEmployeeLeave.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EmployeeLeaveObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EmployeeLeaveObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves a specific employee\'s leave balances using a unique employee ID
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     */     
    public async getEmployeeLeaveBalances (xeroTenantId: string, employeeID: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EmployeeLeaveBalances;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}/LeaveBalances'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getEmployeeLeaveBalances.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling getEmployeeLeaveBalances.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EmployeeLeaveBalances;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EmployeeLeaveBalances");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves a specific employee\'s leave periods using a unique employee ID
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     * @param startDate Filter by start date
     * @param endDate Filter by end date
     */     
    public async getEmployeeLeavePeriods (xeroTenantId: string, employeeID: string, startDate?: string, endDate?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: LeavePeriods;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}/LeavePeriods'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getEmployeeLeavePeriods.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling getEmployeeLeavePeriods.');
        }

        if (startDate !== undefined) {
            localVarQueryParameters['startDate'] = ObjectSerializer.serialize(startDate, "string");
        }

        if (endDate !== undefined) {
            localVarQueryParameters['endDate'] = ObjectSerializer.serialize(endDate, "string");
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: LeavePeriods;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "LeavePeriods");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves a specific employee\'s leave types using a unique employee ID
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     */     
    public async getEmployeeLeaveTypes (xeroTenantId: string, employeeID: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EmployeeLeaveTypes;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}/LeaveTypes'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getEmployeeLeaveTypes.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling getEmployeeLeaveTypes.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EmployeeLeaveTypes;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EmployeeLeaveTypes");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves a specific employee\'s leave records using a unique employee ID
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     */     
    public async getEmployeeLeaves (xeroTenantId: string, employeeID: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EmployeeLeaves;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}/Leave'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getEmployeeLeaves.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling getEmployeeLeaves.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EmployeeLeaves;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EmployeeLeaves");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves a specific employee\'s openingbalances using a unique employee ID
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     */     
    public async getEmployeeOpeningBalances (xeroTenantId: string, employeeID: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EmployeeOpeningBalancesObject;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}/ukopeningbalances'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getEmployeeOpeningBalances.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling getEmployeeOpeningBalances.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EmployeeOpeningBalancesObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EmployeeOpeningBalancesObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves a specific employee pay templates using a unique employee ID
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     */     
    public async getEmployeePayTemplate (xeroTenantId: string, employeeID: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EmployeePayTemplateObject;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}/PayTemplates'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getEmployeePayTemplate.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling getEmployeePayTemplate.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EmployeePayTemplateObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EmployeePayTemplateObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves a specific employee\'s payment method using a unique employee ID
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     */     
    public async getEmployeePaymentMethod (xeroTenantId: string, employeeID: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: PaymentMethodObject;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}/PaymentMethods'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getEmployeePaymentMethod.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling getEmployeePaymentMethod.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: PaymentMethodObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "PaymentMethodObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves a specific salary and wages record for a specific employee using a unique salary and wage id
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     * @param salaryAndWagesID Id for single pay template earnings object
     */     
    public async getEmployeeSalaryAndWage (xeroTenantId: string, employeeID: string, salaryAndWagesID: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: SalaryAndWages;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}/SalaryAndWages/{SalaryAndWagesID}'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)))
            .replace('{' + 'SalaryAndWagesID' + '}', encodeURIComponent(String(salaryAndWagesID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getEmployeeSalaryAndWage.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling getEmployeeSalaryAndWage.');
        }

        // verify required parameter 'salaryAndWagesID' is not null or undefined
        if (salaryAndWagesID === null || salaryAndWagesID === undefined) {
            throw new Error('Required parameter salaryAndWagesID was null or undefined when calling getEmployeeSalaryAndWage.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: SalaryAndWages;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "SalaryAndWages");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves a specific employee\'s salary and wages by using a unique employee ID
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     * @param page Page number which specifies the set of records to retrieve. By default the number of the records per set is 100.
     */     
    public async getEmployeeSalaryAndWages (xeroTenantId: string, employeeID: string, page?: number, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: SalaryAndWages;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}/SalaryAndWages'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getEmployeeSalaryAndWages.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling getEmployeeSalaryAndWages.');
        }

        if (page !== undefined) {
            localVarQueryParameters['page'] = ObjectSerializer.serialize(page, "number");
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: SalaryAndWages;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "SalaryAndWages");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves a specific employee\'s leave balances using a unique employee ID
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     * @param leaveType Filter by the type of statutory leave
     * @param asOfDate The date from which to calculate balance remaining. If not specified, current date UTC is used.
     */     
    public async getEmployeeStatutoryLeaveBalances (xeroTenantId: string, employeeID: string, leaveType?: string, asOfDate?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EmployeeStatutoryLeaveBalanceObject;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}/StatutoryLeaveBalance'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getEmployeeStatutoryLeaveBalances.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling getEmployeeStatutoryLeaveBalances.');
        }

        if (leaveType !== undefined) {
            localVarQueryParameters['LeaveType'] = ObjectSerializer.serialize(leaveType, "string");
        }

        if (asOfDate !== undefined) {
            localVarQueryParameters['AsOfDate'] = ObjectSerializer.serialize(asOfDate, "string");
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EmployeeStatutoryLeaveBalanceObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EmployeeStatutoryLeaveBalanceObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves a statutory sick leave for an employee
     * @param xeroTenantId Xero identifier for Tenant
     * @param statutorySickLeaveID Statutory sick leave id for single object
     */     
    public async getEmployeeStatutorySickLeave (xeroTenantId: string, statutorySickLeaveID: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EmployeeStatutorySickLeaveObject;  }> {
        const localVarPath = this.basePath + '/StatutoryLeaves/Sick/{StatutorySickLeaveID}'
            .replace('{' + 'StatutorySickLeaveID' + '}', encodeURIComponent(String(statutorySickLeaveID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getEmployeeStatutorySickLeave.');
        }

        // verify required parameter 'statutorySickLeaveID' is not null or undefined
        if (statutorySickLeaveID === null || statutorySickLeaveID === undefined) {
            throw new Error('Required parameter statutorySickLeaveID was null or undefined when calling getEmployeeStatutorySickLeave.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EmployeeStatutorySickLeaveObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EmployeeStatutorySickLeaveObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves tax records for a specific employee using a unique employee ID
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     */     
    public async getEmployeeTax (xeroTenantId: string, employeeID: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EmployeeTaxObject;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}/Tax'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getEmployeeTax.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling getEmployeeTax.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EmployeeTaxObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EmployeeTaxObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves employees
     * @param xeroTenantId Xero identifier for Tenant
     * @param filter Filter by first name, lastname, and/or whether they are an off-payroll worker
     * @param page Page number which specifies the set of records to retrieve. By default the number of the records per set is 100.
     */     
    public async getEmployees (xeroTenantId: string, filter?: string, page?: number, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: Employees;  }> {
        const localVarPath = this.basePath + '/Employees';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getEmployees.');
        }

        if (filter !== undefined) {
            localVarQueryParameters['filter'] = ObjectSerializer.serialize(filter, "string");
        }

        if (page !== undefined) {
            localVarQueryParameters['page'] = ObjectSerializer.serialize(page, "number");
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: Employees;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "Employees");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves a specific leave type by using a unique leave type ID
     * @param xeroTenantId Xero identifier for Tenant
     * @param leaveTypeID Identifier for the leave type
     */     
    public async getLeaveType (xeroTenantId: string, leaveTypeID: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: LeaveTypeObject;  }> {
        const localVarPath = this.basePath + '/LeaveTypes/{LeaveTypeID}'
            .replace('{' + 'LeaveTypeID' + '}', encodeURIComponent(String(leaveTypeID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getLeaveType.');
        }

        // verify required parameter 'leaveTypeID' is not null or undefined
        if (leaveTypeID === null || leaveTypeID === undefined) {
            throw new Error('Required parameter leaveTypeID was null or undefined when calling getLeaveType.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: LeaveTypeObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "LeaveTypeObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves leave types
     * @param xeroTenantId Xero identifier for Tenant
     * @param page Page number which specifies the set of records to retrieve. By default the number of the records per set is 100.
     * @param activeOnly Filters leave types by active status. By default the API returns all leave types.
     */     
    public async getLeaveTypes (xeroTenantId: string, page?: number, activeOnly?: boolean, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: LeaveTypes;  }> {
        const localVarPath = this.basePath + '/LeaveTypes';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getLeaveTypes.');
        }

        if (page !== undefined) {
            localVarQueryParameters['page'] = ObjectSerializer.serialize(page, "number");
        }

        if (activeOnly !== undefined) {
            localVarQueryParameters['ActiveOnly'] = ObjectSerializer.serialize(activeOnly, "boolean");
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: LeaveTypes;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "LeaveTypes");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves a specific pay run by using a unique pay run ID
     * @param xeroTenantId Xero identifier for Tenant
     * @param payRunID Identifier for the pay run
     */     
    public async getPayRun (xeroTenantId: string, payRunID: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: PayRunObject;  }> {
        const localVarPath = this.basePath + '/PayRuns/{PayRunID}'
            .replace('{' + 'PayRunID' + '}', encodeURIComponent(String(payRunID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getPayRun.');
        }

        // verify required parameter 'payRunID' is not null or undefined
        if (payRunID === null || payRunID === undefined) {
            throw new Error('Required parameter payRunID was null or undefined when calling getPayRun.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: PayRunObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "PayRunObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves a specific payrun calendar by using a unique payrun calendar ID
     * @param xeroTenantId Xero identifier for Tenant
     * @param payRunCalendarID Identifier for the payrun calendars
     */     
    public async getPayRunCalendar (xeroTenantId: string, payRunCalendarID: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: PayRunCalendarObject;  }> {
        const localVarPath = this.basePath + '/PayRunCalendars/{PayRunCalendarID}'
            .replace('{' + 'PayRunCalendarID' + '}', encodeURIComponent(String(payRunCalendarID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getPayRunCalendar.');
        }

        // verify required parameter 'payRunCalendarID' is not null or undefined
        if (payRunCalendarID === null || payRunCalendarID === undefined) {
            throw new Error('Required parameter payRunCalendarID was null or undefined when calling getPayRunCalendar.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: PayRunCalendarObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "PayRunCalendarObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves payrun calendars
     * @param xeroTenantId Xero identifier for Tenant
     * @param page Page number which specifies the set of records to retrieve. By default the number of the records per set is 100.
     */     
    public async getPayRunCalendars (xeroTenantId: string, page?: number, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: PayRunCalendars;  }> {
        const localVarPath = this.basePath + '/PayRunCalendars';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getPayRunCalendars.');
        }

        if (page !== undefined) {
            localVarQueryParameters['page'] = ObjectSerializer.serialize(page, "number");
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: PayRunCalendars;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "PayRunCalendars");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves pay runs
     * @param xeroTenantId Xero identifier for Tenant
     * @param page Page number which specifies the set of records to retrieve. By default the number of the records per set is 100.
     * @param status By default get payruns will return all the payruns for an organization. You can add GET https://api.xero.com/payroll.xro/2.0/payRuns?statu&#x3D;{PayRunStatus} to filter the payruns by status.
     */     
    public async getPayRuns (xeroTenantId: string, page?: number, status?: 'Draft' | 'Posted', options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: PayRuns;  }> {
        const localVarPath = this.basePath + '/PayRuns';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getPayRuns.');
        }

        if (page !== undefined) {
            localVarQueryParameters['page'] = ObjectSerializer.serialize(page, "number");
        }

        if (status !== undefined) {
            localVarQueryParameters['status'] = ObjectSerializer.serialize(status, "'Draft' | 'Posted'");
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: PayRuns;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "PayRuns");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves a specific payslip by using a unique payslip ID
     * @param xeroTenantId Xero identifier for Tenant
     * @param payslipID Identifier for the payslip
     */     
    public async getPaySlip (xeroTenantId: string, payslipID: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: PayslipObject;  }> {
        const localVarPath = this.basePath + '/Payslips/{PayslipID}'
            .replace('{' + 'PayslipID' + '}', encodeURIComponent(String(payslipID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getPaySlip.');
        }

        // verify required parameter 'payslipID' is not null or undefined
        if (payslipID === null || payslipID === undefined) {
            throw new Error('Required parameter payslipID was null or undefined when calling getPaySlip.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: PayslipObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "PayslipObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves payslips
     * @param xeroTenantId Xero identifier for Tenant
     * @param payRunID PayrunID which specifies the containing payrun of payslips to retrieve. By default, the API does not group payslips by payrun.
     * @param page Page number which specifies the set of records to retrieve. By default the number of the records per set is 100.
     */     
    public async getPaySlips (xeroTenantId: string, payRunID: string, page?: number, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: Payslips;  }> {
        const localVarPath = this.basePath + '/Payslips';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getPaySlips.');
        }

        // verify required parameter 'payRunID' is not null or undefined
        if (payRunID === null || payRunID === undefined) {
            throw new Error('Required parameter payRunID was null or undefined when calling getPaySlips.');
        }

        if (page !== undefined) {
            localVarQueryParameters['page'] = ObjectSerializer.serialize(page, "number");
        }

        if (payRunID !== undefined) {
            localVarQueryParameters['PayRunID'] = ObjectSerializer.serialize(payRunID, "string");
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: Payslips;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "Payslips");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves a specific reimbursement by using a unique reimbursement id
     * @param xeroTenantId Xero identifier for Tenant
     * @param reimbursementID Identifier for the reimbursement
     */     
    public async getReimbursement (xeroTenantId: string, reimbursementID: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: ReimbursementObject;  }> {
        const localVarPath = this.basePath + '/Reimbursements/{ReimbursementID}'
            .replace('{' + 'ReimbursementID' + '}', encodeURIComponent(String(reimbursementID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getReimbursement.');
        }

        // verify required parameter 'reimbursementID' is not null or undefined
        if (reimbursementID === null || reimbursementID === undefined) {
            throw new Error('Required parameter reimbursementID was null or undefined when calling getReimbursement.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: ReimbursementObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "ReimbursementObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves reimbursements
     * @param xeroTenantId Xero identifier for Tenant
     * @param page Page number which specifies the set of records to retrieve. By default the number of the records per set is 100.
     */     
    public async getReimbursements (xeroTenantId: string, page?: number, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: Reimbursements;  }> {
        const localVarPath = this.basePath + '/Reimbursements';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getReimbursements.');
        }

        if (page !== undefined) {
            localVarQueryParameters['page'] = ObjectSerializer.serialize(page, "number");
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: Reimbursements;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "Reimbursements");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves payroll settings
     * @param xeroTenantId Xero identifier for Tenant
     */     
    public async getSettings (xeroTenantId: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: Settings;  }> {
        const localVarPath = this.basePath + '/Settings';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getSettings.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: Settings;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "Settings");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves a specific employee\'s summary of statutory leaves using a unique employee ID
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     * @param activeOnly Filter response with leaves that are currently active or yet to be taken. If not specified, all leaves (past, current, and future scheduled) are returned
     */     
    public async getStatutoryLeaveSummary (xeroTenantId: string, employeeID: string, activeOnly?: boolean, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EmployeeStatutoryLeavesSummaries;  }> {
        const localVarPath = this.basePath + '/StatutoryLeaves/Summary/{EmployeeID}'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getStatutoryLeaveSummary.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling getStatutoryLeaveSummary.');
        }

        if (activeOnly !== undefined) {
            localVarQueryParameters['activeOnly'] = ObjectSerializer.serialize(activeOnly, "boolean");
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EmployeeStatutoryLeavesSummaries;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EmployeeStatutoryLeavesSummaries");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieve a specific timesheet by using a unique timesheet ID
     * @param xeroTenantId Xero identifier for Tenant
     * @param timesheetID Identifier for the timesheet
     */     
    public async getTimesheet (xeroTenantId: string, timesheetID: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: TimesheetObject;  }> {
        const localVarPath = this.basePath + '/Timesheets/{TimesheetID}'
            .replace('{' + 'TimesheetID' + '}', encodeURIComponent(String(timesheetID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getTimesheet.');
        }

        // verify required parameter 'timesheetID' is not null or undefined
        if (timesheetID === null || timesheetID === undefined) {
            throw new Error('Required parameter timesheetID was null or undefined when calling getTimesheet.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: TimesheetObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "TimesheetObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves timesheets
     * @param xeroTenantId Xero identifier for Tenant
     * @param page Page number which specifies the set of records to retrieve. By default the number of the records per set is 100.
     * @param filter Filter by employeeId and/or payrollCalendarId
     * @param status filter results by any timesheets with a matching timesheet status
     * @param startDate filter results by any timesheets with a startDate on or after the provided date
     * @param endDate filter results by any timesheets with a endDate on or before the provided date
     * @param sort sort the order of timesheets returned. The default is based on the timesheets createdDate, sorted oldest to newest. Currently, the only other option is to reverse the order based on the timesheets startDate, sorted newest to oldest.
     */     
    public async getTimesheets (xeroTenantId: string, page?: number, filter?: string, status?: string, startDate?: string, endDate?: string, sort?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: Timesheets;  }> {
        const localVarPath = this.basePath + '/Timesheets';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getTimesheets.');
        }

        if (page !== undefined) {
            localVarQueryParameters['page'] = ObjectSerializer.serialize(page, "number");
        }

        if (filter !== undefined) {
            localVarQueryParameters['filter'] = ObjectSerializer.serialize(filter, "string");
        }

        if (status !== undefined) {
            localVarQueryParameters['status'] = ObjectSerializer.serialize(status, "string");
        }

        if (startDate !== undefined) {
            localVarQueryParameters['startDate'] = ObjectSerializer.serialize(startDate, "string");
        }

        if (endDate !== undefined) {
            localVarQueryParameters['endDate'] = ObjectSerializer.serialize(endDate, "string");
        }

        if (sort !== undefined) {
            localVarQueryParameters['sort'] = ObjectSerializer.serialize(sort, "string");
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: Timesheets;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "Timesheets");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Retrieves tracking categories
     * @param xeroTenantId Xero identifier for Tenant
     */     
    public async getTrackingCategories (xeroTenantId: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: TrackingCategories;  }> {
        const localVarPath = this.basePath + '/Settings/trackingCategories';
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling getTrackingCategories.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'GET',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: TrackingCategories;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "TrackingCategories");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Reverts a specific timesheet to draft
     * @param xeroTenantId Xero identifier for Tenant
     * @param timesheetID Identifier for the timesheet
     * @param idempotencyKey This allows you to safely retry requests without the risk of duplicate processing. 128 character max.
     */     
    public async revertTimesheet (xeroTenantId: string, timesheetID: string, idempotencyKey?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: TimesheetObject;  }> {
        const localVarPath = this.basePath + '/Timesheets/{TimesheetID}/RevertToDraft'
            .replace('{' + 'TimesheetID' + '}', encodeURIComponent(String(timesheetID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling revertTimesheet.');
        }

        // verify required parameter 'timesheetID' is not null or undefined
        if (timesheetID === null || timesheetID === undefined) {
            throw new Error('Required parameter timesheetID was null or undefined when calling revertTimesheet.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Idempotency-Key'] = ObjectSerializer.serialize(idempotencyKey, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'POST',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: {},
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: TimesheetObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "TimesheetObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Updates a specific employee\'s detail
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     * @param employee 
     * @param idempotencyKey This allows you to safely retry requests without the risk of duplicate processing. 128 character max.
     */     
    public async updateEmployee (xeroTenantId: string, employeeID: string, employee: Employee, idempotencyKey?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EmployeeObject;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling updateEmployee.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling updateEmployee.');
        }

        // verify required parameter 'employee' is not null or undefined
        if (employee === null || employee === undefined) {
            throw new Error('Required parameter employee was null or undefined when calling updateEmployee.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Idempotency-Key'] = ObjectSerializer.serialize(idempotencyKey, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'PUT',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: ObjectSerializer.serialize(employee, "Employee"),
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EmployeeObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EmployeeObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Updates a specific employee\'s earnings template records
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     * @param payTemplateEarningID Id for single pay template earnings object
     * @param earningsTemplate 
     * @param idempotencyKey This allows you to safely retry requests without the risk of duplicate processing. 128 character max.
     */     
    public async updateEmployeeEarningsTemplate (xeroTenantId: string, employeeID: string, payTemplateEarningID: string, earningsTemplate: EarningsTemplate, idempotencyKey?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EarningsTemplateObject;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}/PayTemplates/earnings/{PayTemplateEarningID}'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)))
            .replace('{' + 'PayTemplateEarningID' + '}', encodeURIComponent(String(payTemplateEarningID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling updateEmployeeEarningsTemplate.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling updateEmployeeEarningsTemplate.');
        }

        // verify required parameter 'payTemplateEarningID' is not null or undefined
        if (payTemplateEarningID === null || payTemplateEarningID === undefined) {
            throw new Error('Required parameter payTemplateEarningID was null or undefined when calling updateEmployeeEarningsTemplate.');
        }

        // verify required parameter 'earningsTemplate' is not null or undefined
        if (earningsTemplate === null || earningsTemplate === undefined) {
            throw new Error('Required parameter earningsTemplate was null or undefined when calling updateEmployeeEarningsTemplate.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Idempotency-Key'] = ObjectSerializer.serialize(idempotencyKey, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'PUT',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: ObjectSerializer.serialize(earningsTemplate, "EarningsTemplate"),
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EarningsTemplateObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EarningsTemplateObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Updates a specific employee\'s leave records
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     * @param leaveID Leave id for single object
     * @param employeeLeave 
     * @param idempotencyKey This allows you to safely retry requests without the risk of duplicate processing. 128 character max.
     */     
    public async updateEmployeeLeave (xeroTenantId: string, employeeID: string, leaveID: string, employeeLeave: EmployeeLeave, idempotencyKey?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EmployeeLeaveObject;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}/Leave/{LeaveID}'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)))
            .replace('{' + 'LeaveID' + '}', encodeURIComponent(String(leaveID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling updateEmployeeLeave.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling updateEmployeeLeave.');
        }

        // verify required parameter 'leaveID' is not null or undefined
        if (leaveID === null || leaveID === undefined) {
            throw new Error('Required parameter leaveID was null or undefined when calling updateEmployeeLeave.');
        }

        // verify required parameter 'employeeLeave' is not null or undefined
        if (employeeLeave === null || employeeLeave === undefined) {
            throw new Error('Required parameter employeeLeave was null or undefined when calling updateEmployeeLeave.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Idempotency-Key'] = ObjectSerializer.serialize(idempotencyKey, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'PUT',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: ObjectSerializer.serialize(employeeLeave, "EmployeeLeave"),
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EmployeeLeaveObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EmployeeLeaveObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Updates a specific employee\'s opening balances
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     * @param employeeOpeningBalances 
     * @param idempotencyKey This allows you to safely retry requests without the risk of duplicate processing. 128 character max.
     */     
    public async updateEmployeeOpeningBalances (xeroTenantId: string, employeeID: string, employeeOpeningBalances: EmployeeOpeningBalances, idempotencyKey?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: EmployeeOpeningBalancesObject;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}/ukopeningbalances'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling updateEmployeeOpeningBalances.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling updateEmployeeOpeningBalances.');
        }

        // verify required parameter 'employeeOpeningBalances' is not null or undefined
        if (employeeOpeningBalances === null || employeeOpeningBalances === undefined) {
            throw new Error('Required parameter employeeOpeningBalances was null or undefined when calling updateEmployeeOpeningBalances.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Idempotency-Key'] = ObjectSerializer.serialize(idempotencyKey, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'PUT',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: ObjectSerializer.serialize(employeeOpeningBalances, "EmployeeOpeningBalances"),
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: EmployeeOpeningBalancesObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "EmployeeOpeningBalancesObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Updates salary and wages record for a specific employee
     * @param xeroTenantId Xero identifier for Tenant
     * @param employeeID Employee id for single object
     * @param salaryAndWagesID Id for single pay template earnings object
     * @param salaryAndWage 
     * @param idempotencyKey This allows you to safely retry requests without the risk of duplicate processing. 128 character max.
     */     
    public async updateEmployeeSalaryAndWage (xeroTenantId: string, employeeID: string, salaryAndWagesID: string, salaryAndWage: SalaryAndWage, idempotencyKey?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: SalaryAndWageObject;  }> {
        const localVarPath = this.basePath + '/Employees/{EmployeeID}/SalaryAndWages/{SalaryAndWagesID}'
            .replace('{' + 'EmployeeID' + '}', encodeURIComponent(String(employeeID)))
            .replace('{' + 'SalaryAndWagesID' + '}', encodeURIComponent(String(salaryAndWagesID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling updateEmployeeSalaryAndWage.');
        }

        // verify required parameter 'employeeID' is not null or undefined
        if (employeeID === null || employeeID === undefined) {
            throw new Error('Required parameter employeeID was null or undefined when calling updateEmployeeSalaryAndWage.');
        }

        // verify required parameter 'salaryAndWagesID' is not null or undefined
        if (salaryAndWagesID === null || salaryAndWagesID === undefined) {
            throw new Error('Required parameter salaryAndWagesID was null or undefined when calling updateEmployeeSalaryAndWage.');
        }

        // verify required parameter 'salaryAndWage' is not null or undefined
        if (salaryAndWage === null || salaryAndWage === undefined) {
            throw new Error('Required parameter salaryAndWage was null or undefined when calling updateEmployeeSalaryAndWage.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Idempotency-Key'] = ObjectSerializer.serialize(idempotencyKey, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'PUT',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: ObjectSerializer.serialize(salaryAndWage, "SalaryAndWage"),
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: SalaryAndWageObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "SalaryAndWageObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Updates a specific pay run
     * @param xeroTenantId Xero identifier for Tenant
     * @param payRunID Identifier for the pay run
     * @param payRun 
     * @param idempotencyKey This allows you to safely retry requests without the risk of duplicate processing. 128 character max.
     */     
    public async updatePayRun (xeroTenantId: string, payRunID: string, payRun: PayRun, idempotencyKey?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: PayRunObject;  }> {
        const localVarPath = this.basePath + '/PayRuns/{PayRunID}'
            .replace('{' + 'PayRunID' + '}', encodeURIComponent(String(payRunID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling updatePayRun.');
        }

        // verify required parameter 'payRunID' is not null or undefined
        if (payRunID === null || payRunID === undefined) {
            throw new Error('Required parameter payRunID was null or undefined when calling updatePayRun.');
        }

        // verify required parameter 'payRun' is not null or undefined
        if (payRun === null || payRun === undefined) {
            throw new Error('Required parameter payRun was null or undefined when calling updatePayRun.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Idempotency-Key'] = ObjectSerializer.serialize(idempotencyKey, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'PUT',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: ObjectSerializer.serialize(payRun, "PayRun"),
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: PayRunObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "PayRunObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
    /**
     * 
     * @summary Updates a specific timesheet line for a specific timesheet
     * @param xeroTenantId Xero identifier for Tenant
     * @param timesheetID Identifier for the timesheet
     * @param timesheetLineID Identifier for the timesheet line
     * @param timesheetLine 
     * @param idempotencyKey This allows you to safely retry requests without the risk of duplicate processing. 128 character max.
     */     
    public async updateTimesheetLine (xeroTenantId: string, timesheetID: string, timesheetLineID: string, timesheetLine: TimesheetLine, idempotencyKey?: string, options: {headers: {[name: string]: string}} = {headers: {}}) : Promise<{ response: AxiosResponse; body: TimesheetLineObject;  }> {
        const localVarPath = this.basePath + '/Timesheets/{TimesheetID}/Lines/{TimesheetLineID}'
            .replace('{' + 'TimesheetID' + '}', encodeURIComponent(String(timesheetID)))
            .replace('{' + 'TimesheetLineID' + '}', encodeURIComponent(String(timesheetLineID)));
        let localVarQueryParameters: any = {};
        let localVarHeaderParams: any = (<any>Object).assign({}, this.defaultHeaders);
        let localVarFormParams: any = {};
        let acceptHeadersFromSpec = [
                "application/json"
            ];
        const isBufferType = acceptHeadersFromSpec.includes("application/pdf")|| acceptHeadersFromSpec.includes("application/octet-stream") || acceptHeadersFromSpec.includes("application/jpg");
		const responseTypeOption = isBufferType ? "arraybuffer" : "json";

        // verify required parameter 'xeroTenantId' is not null or undefined
        if (xeroTenantId === null || xeroTenantId === undefined) {
            throw new Error('Required parameter xeroTenantId was null or undefined when calling updateTimesheetLine.');
        }

        // verify required parameter 'timesheetID' is not null or undefined
        if (timesheetID === null || timesheetID === undefined) {
            throw new Error('Required parameter timesheetID was null or undefined when calling updateTimesheetLine.');
        }

        // verify required parameter 'timesheetLineID' is not null or undefined
        if (timesheetLineID === null || timesheetLineID === undefined) {
            throw new Error('Required parameter timesheetLineID was null or undefined when calling updateTimesheetLine.');
        }

        // verify required parameter 'timesheetLine' is not null or undefined
        if (timesheetLine === null || timesheetLine === undefined) {
            throw new Error('Required parameter timesheetLine was null or undefined when calling updateTimesheetLine.');
        }

        localVarHeaderParams['Xero-Tenant-Id'] = ObjectSerializer.serialize(xeroTenantId, "string");
        localVarHeaderParams['Idempotency-Key'] = ObjectSerializer.serialize(idempotencyKey, "string");
        localVarHeaderParams['Accept'] = acceptHeadersFromSpec.join();
        (<any>Object).assign(localVarHeaderParams, options.headers);
        let localVarUseFormData = false;

        let localVarRequestOptions: AxiosRequestConfig = {
            method: 'PUT',
            params: localVarQueryParameters,
            headers: localVarHeaderParams,
            url: localVarPath,
            responseType: responseTypeOption,
            data: ObjectSerializer.serialize(timesheetLine, "TimesheetLine"),
        };

        let authenticationPromise = Promise.resolve();
        authenticationPromise = authenticationPromise.then(() => this.authentications.OAuth2.applyToRequest(localVarRequestOptions));

        authenticationPromise = authenticationPromise.then(() => this.authentications.default.applyToRequest(localVarRequestOptions));
        return authenticationPromise.then(() => {
            if (Object.keys(localVarFormParams).length) {
                if (localVarUseFormData) {
                    (<any>localVarRequestOptions).data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'Content-Type': 'multipart/form-data' };
                } else {
                    localVarRequestOptions.data = localVarFormParams;
                    localVarRequestOptions.headers = { ...localVarRequestOptions.headers, 'content-type': 'application/x-www-form-urlencoded' };
                }
            }
            return new Promise<{ response: AxiosResponse; body: TimesheetLineObject;  }>(async (resolve, reject) => {
            let body = null
            try {
                const response = await axios(localVarRequestOptions)
                         body = ObjectSerializer.deserialize(response.data, "TimesheetLineObject");
                        if (response.status && response.status >= 200 && response.status <= 299) {
                            resolve({ response: response, body: body });
                        } else {
                            reject({ response: response, body: body });
                        }
                }
                catch(error) {
                     const errorResponse = new ApiError(error)
					 reject(JSON.stringify(errorResponse.generateError()))
                }
            });
        });
    }
}