node-paymo-api 0.0.3 → 0.0.5

package/dist/resources/entries/types.d.ts

@@ -0,0 +1,53 @@
+import { FilterOperator, GenericListConfig, Merge } from "../../types";
+export interface TimeEntriesTypeRead {
+    readonly id: number;
+    readonly project_id: number;
+    readonly created_on: string;
+    readonly updated_on: string;
+}
+export interface TimeEntriesTypeUpdate {
+    task_id?: number;
+    user_id?: number;
+    is_bulk?: boolean;
+    start_time?: string;
+    end_time?: string;
+    date?: string;
+    duration?: number;
+    description?: string;
+    added_manually?: boolean;
+    billed?: boolean;
+}
+export type TimeEntriesTypeResponse = Merge<TimeEntriesTypeUpdate, Merge<TimeEntriesTypeRead, {}>>;
+interface TimeEntriesTypeCreateCommon extends TimeEntriesTypeUpdate {
+    task_id: number;
+}
+interface TimeEntriesTypeCreateRange extends TimeEntriesTypeCreateCommon {
+    start_time: string;
+    end_time: string;
+}
+interface TimeEntriesTypeCreateDuration extends TimeEntriesTypeCreateCommon {
+    date: string;
+    duration: number;
+}
+export type TimeEntriesTypeCreate = TimeEntriesTypeCreateRange | TimeEntriesTypeCreateDuration;
+export interface TimeEntriesTypeFilter {
+    project_id?: number;
+    task_id?: number;
+    user_id?: number;
+    client_id?: number;
+    time_interval?: string[];
+    end_time?: string | null;
+}
+export interface TimeEntriesFilterCondition extends TimeEntriesTypeFilter {
+    _custom?: {
+        [k: string]: {
+            key?: Extract<keyof TimeEntriesTypeFilter, string>;
+            operator?: FilterOperator;
+            value: string | number | boolean | null | number[];
+        };
+    };
+}
+export interface TimeEntriesListConfig extends GenericListConfig {
+    filter?: TimeEntriesFilterCondition;
+}
+export {};

package/dist/resources/entries/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/resources/estimates/EstimateItem.d.ts

@@ -0,0 +1,3 @@
+export declare const EstimateItem: {};
+declare const _default: null;
+export default _default;

package/dist/resources/estimates/EstimateItem.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EstimateItem = void 0;
+exports.EstimateItem = {};
+exports.default = null;

package/dist/resources/estimates/Estimates.d.ts

@@ -0,0 +1,18 @@
+import { AbstractResource, AbstractResourceInterface } from '../../abstract';
+import { AuthInterface } from "../../types";
+import { EstimatesListConfig, EstimatesTypeCreate, EstimatesTypeResponse, EstimatesTypeUpdate } from "./types";
+export interface EstimatesHandler extends AbstractResourceInterface {
+    get: (id: number) => Promise<EstimatesTypeResponse | null>;
+    list: (config?: EstimatesListConfig) => Promise<EstimatesTypeResponse[]>;
+    create: (d: EstimatesTypeCreate) => Promise<EstimatesTypeResponse | null>;
+    update: (id: number, data: EstimatesTypeUpdate) => Promise<EstimatesTypeResponse | null>;
+    delete: (id: number) => Promise<boolean>;
+}
+export declare class Estimates extends AbstractResource implements EstimatesHandler {
+    constructor(auth: AuthInterface);
+    get: (id: number) => Promise<EstimatesTypeResponse | null>;
+    list: (config?: EstimatesListConfig) => Promise<EstimatesTypeResponse[]>;
+    create: (data: EstimatesTypeCreate) => Promise<EstimatesTypeResponse | null>;
+    update: (id: number, data: EstimatesTypeUpdate) => Promise<EstimatesTypeResponse | null>;
+    delete: (id: number) => Promise<boolean>;
+}

package/dist/resources/estimates/Estimates.js

@@ -0,0 +1,34 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Estimates = void 0;
+const abstract_1 = require("../../abstract");
+class Estimates extends abstract_1.AbstractResource {
+    constructor(auth) {
+        super(auth, 'estimates');
+        this.get = (id) => __awaiter(this, void 0, void 0, function* () {
+            return (yield this.baseGet(id));
+        });
+        this.list = (...args_1) => __awaiter(this, [...args_1], void 0, function* (config = {}) {
+            return (yield this.baseList(config));
+        });
+        this.create = (data) => __awaiter(this, void 0, void 0, function* () {
+            return (yield this.baseCreate(data));
+        });
+        this.update = (id, data) => __awaiter(this, void 0, void 0, function* () {
+            return (yield this.baseUpdate(id, data));
+        });
+        this.delete = (id) => __awaiter(this, void 0, void 0, function* () {
+            return yield this.baseDelete(id);
+        });
+    }
+}
+exports.Estimates = Estimates;

package/dist/resources/estimates/index.d.ts

@@ -0,0 +1,2 @@
+export { Estimates, EstimatesHandler } from './Estimates';
+export { EstimateItem } from './EstimateItem';

package/dist/resources/estimates/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EstimateItem = exports.Estimates = void 0;
+var Estimates_1 = require("./Estimates");
+Object.defineProperty(exports, "Estimates", { enumerable: true, get: function () { return Estimates_1.Estimates; } });
+var EstimateItem_1 = require("./EstimateItem");
+Object.defineProperty(exports, "EstimateItem", { enumerable: true, get: function () { return EstimateItem_1.EstimateItem; } });

package/dist/resources/estimates/types.d.ts

@@ -0,0 +1,76 @@
+import { FilterOperator, GenericListConfig, Merge, PaymoCurrency } from "../../types";
+export interface EstimatesTypeRead {
+    readonly id: number;
+    readonly created_on: string;
+    readonly updated_on: string;
+    readonly subtotal: number;
+    readonly total: number;
+    readonly tax_amount: number;
+    readonly tax2_amount: number;
+    readonly permalink: string;
+    readonly pdf_link: string;
+}
+export interface EstimatesTypeUpdate {
+    number?: string;
+    client_id?: number;
+    template_id?: number;
+    status?: 'draft' | 'sent' | 'viewed' | 'accepted' | 'invoiced' | 'void';
+    currency?: PaymoCurrency;
+    date?: string;
+    tax?: number;
+    tax2?: number;
+    tax_on_tax?: boolean;
+    bill_to?: string;
+    company_info?: string;
+    footer?: string;
+    notes?: string;
+    tax_text?: string;
+    tax2_text?: string;
+    title?: string;
+    invoice_id?: number;
+    estimateitems?: EstimateItemTypeCreate[];
+}
+export type EstimatesTypeResponse = Merge<EstimatesTypeUpdate, Merge<EstimatesTypeRead, {
+    estimateitems?: EstimateItemTypeRead[];
+}>>;
+export interface EstimatesTypeCreate extends EstimatesTypeUpdate {
+    client_id: number;
+    currency: PaymoCurrency;
+    items?: EstimateItemTypeCreate[];
+}
+export interface EstimatesTypeFilter extends EstimatesTypeUpdate {
+    created_on?: string;
+    updated_on?: string;
+    subtotal?: number;
+    total?: number;
+    tax_amount?: number;
+    tax2_amount?: number;
+}
+export interface EstimatesFilterCondition extends EstimatesTypeFilter {
+    _custom?: {
+        [k: string]: {
+            key?: Extract<keyof EstimatesTypeFilter, string>;
+            operator?: FilterOperator;
+            value: string | number | boolean | null | number[];
+        };
+    };
+}
+export interface EstimatesListConfig extends GenericListConfig {
+    filter?: EstimatesFilterCondition;
+}
+export interface EstimateItemTypeCreate {
+    item: string;
+    description: string;
+    price_unit: number;
+    quantity: number;
+    apply_tax?: boolean;
+    seq?: number | null;
+}
+export interface EstimateItemTypeRead extends EstimateItemTypeCreate {
+    readonly id: number;
+    readonly estimate_id: number;
+    apply_tax: boolean;
+    seq: number | null;
+    readonly created_on: string;
+    readonly updated_on: string;
+}

package/dist/resources/estimates/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/resources/estimatetemplates/index.d.ts

@@ -0,0 +1,18 @@
+import { AbstractResource, AbstractResourceInterface } from '../../abstract';
+import { AuthInterface } from "../../types";
+import { EstimateTemplatesListConfig, EstimateTemplatesTypeCreate, EstimateTemplatesTypeResponse, EstimateTemplatesTypeUpdate } from "./types";
+export interface EstimateTemplatesHandler extends AbstractResourceInterface {
+    get: (id: number) => Promise<EstimateTemplatesTypeResponse | null>;
+    list: (config?: EstimateTemplatesListConfig) => Promise<EstimateTemplatesTypeResponse[]>;
+    create: (d: EstimateTemplatesTypeCreate) => Promise<EstimateTemplatesTypeResponse | null>;
+    update: (id: number, data: EstimateTemplatesTypeUpdate) => Promise<EstimateTemplatesTypeResponse | null>;
+    delete: (id: number) => Promise<boolean>;
+}
+export declare class EstimateTemplates extends AbstractResource implements EstimateTemplatesHandler {
+    constructor(auth: AuthInterface);
+    get: (id: number) => Promise<EstimateTemplatesTypeResponse | null>;
+    list: (config?: EstimateTemplatesListConfig) => Promise<EstimateTemplatesTypeResponse[]>;
+    create: (data: EstimateTemplatesTypeCreate) => Promise<EstimateTemplatesTypeResponse | null>;
+    update: (id: number, data: EstimateTemplatesTypeUpdate) => Promise<EstimateTemplatesTypeResponse | null>;
+    delete: (id: number) => Promise<boolean>;
+}

package/dist/resources/estimatetemplates/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EstimateTemplates = void 0;
+const abstract_1 = require("../../abstract");
+class EstimateTemplates extends abstract_1.AbstractResource {
+    constructor(auth) {
+        super(auth, 'estimatetemplates');
+        this.get = (id) => __awaiter(this, void 0, void 0, function* () {
+            return (yield this.baseGet(id));
+        });
+        this.list = (...args_1) => __awaiter(this, [...args_1], void 0, function* (config = {}) {
+            return (yield this.baseList(config));
+        });
+        this.create = (data) => __awaiter(this, void 0, void 0, function* () {
+            return (yield this.baseCreate(data));
+        });
+        this.update = (id, data) => __awaiter(this, void 0, void 0, function* () {
+            return (yield this.baseUpdate(id, data));
+        });
+        this.delete = (id) => __awaiter(this, void 0, void 0, function* () {
+            return yield this.baseDelete(id);
+        });
+    }
+}
+exports.EstimateTemplates = EstimateTemplates;

package/dist/resources/estimatetemplates/types.d.ts

@@ -0,0 +1,34 @@
+import { FilterOperator, GenericListConfig, Merge } from "../../types";
+export interface EstimateTemplatesTypeRead {
+    readonly id: number;
+    readonly created_on: string;
+    readonly updated_on: string;
+}
+export interface EstimateTemplatesTypeUpdate {
+    name?: string;
+    title?: string;
+    html?: string;
+    css?: string;
+    is_default?: boolean;
+}
+export type EstimateTemplatesTypeResponse = Merge<EstimateTemplatesTypeUpdate, Merge<EstimateTemplatesTypeRead, {}>>;
+export interface EstimateTemplatesTypeCreate extends EstimateTemplatesTypeUpdate {
+    name: string;
+}
+export interface EstimateTemplatesTypeFilter {
+    id?: number;
+    name?: string;
+    is_default?: boolean;
+}
+export interface EstimateTemplatesFilterCondition extends EstimateTemplatesTypeFilter {
+    _custom?: {
+        [k: string]: {
+            key?: Extract<keyof EstimateTemplatesTypeFilter, string>;
+            operator?: FilterOperator;
+            value: string | number | boolean | null | number[];
+        };
+    };
+}
+export interface EstimateTemplatesListConfig extends GenericListConfig {
+    filter?: EstimateTemplatesFilterCondition;
+}

package/dist/resources/estimatetemplates/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/resources/expenses/index.d.ts

@@ -0,0 +1,18 @@
+import { AbstractResource, AbstractResourceInterface } from '../../abstract';
+import { AuthInterface } from "../../types";
+import { ExpensesListConfig, ExpensesTypeCreate, ExpensesTypeResponse, ExpensesTypeUpdate } from "./types";
+export interface ExpensesHandler extends AbstractResourceInterface {
+    get: (id: number) => Promise<ExpensesTypeResponse | null>;
+    list: (config?: ExpensesListConfig) => Promise<ExpensesTypeResponse[]>;
+    create: (d: ExpensesTypeCreate) => Promise<ExpensesTypeResponse | null>;
+    update: (id: number, data: ExpensesTypeUpdate) => Promise<ExpensesTypeResponse | null>;
+    delete: (id: number) => Promise<boolean>;
+}
+export declare class Expenses extends AbstractResource implements ExpensesHandler {
+    constructor(auth: AuthInterface);
+    get: (id: number) => Promise<ExpensesTypeResponse | null>;
+    list: (config?: ExpensesListConfig) => Promise<ExpensesTypeResponse[]>;
+    create: (data: ExpensesTypeCreate) => Promise<ExpensesTypeResponse | null>;
+    update: (id: number, data: ExpensesTypeUpdate) => Promise<ExpensesTypeResponse | null>;
+    delete: (id: number) => Promise<boolean>;
+}

package/dist/resources/expenses/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Expenses = void 0;
+const abstract_1 = require("../../abstract");
+class Expenses extends abstract_1.AbstractResource {
+    constructor(auth) {
+        super(auth, 'expenses');
+        this.get = (id) => __awaiter(this, void 0, void 0, function* () {
+            return (yield this.baseGet(id));
+        });
+        this.list = (...args_1) => __awaiter(this, [...args_1], void 0, function* (config = {}) {
+            return (yield this.baseList(config));
+        });
+        this.create = (data) => __awaiter(this, void 0, void 0, function* () {
+            return (yield this.baseCreate(data));
+        });
+        this.update = (id, data) => __awaiter(this, void 0, void 0, function* () {
+            return (yield this.baseUpdate(id, data));
+        });
+        this.delete = (id) => __awaiter(this, void 0, void 0, function* () {
+            return yield this.baseDelete(id);
+        });
+    }
+}
+exports.Expenses = Expenses;

package/dist/resources/expenses/types.d.ts

@@ -0,0 +1,46 @@
+import { FilterOperator, GenericListConfig, Merge, PaymoCurrency } from "../../types";
+export interface ExpensesTypeRead {
+    readonly id: number;
+    readonly created_on: string;
+    readonly updated_on: string;
+    readonly image_thumb_large?: string;
+    readonly image_thumb_medium?: string;
+    readonly image_thumb_small?: string;
+}
+export interface ExpensesTypeUpdate {
+    client_id?: number;
+    project_id?: number;
+    user_id?: number;
+    amount?: number;
+    currency?: PaymoCurrency;
+    date?: string;
+    notes?: string;
+    invoiced?: boolean;
+    invoice_item_id?: number;
+    tags?: string[];
+    file?: string;
+}
+export type ExpensesTypeResponse = Merge<ExpensesTypeUpdate, Merge<ExpensesTypeRead, {}>>;
+export interface ExpensesTypeCreate extends ExpensesTypeUpdate {
+    client_id: number;
+    currency: PaymoCurrency;
+    amount: number;
+}
+export interface ExpensesTypeFilter {
+    client_id?: number;
+    project_id?: number;
+    user_id?: number;
+    invoice_item_id?: number;
+}
+export interface ExpensesFilterCondition extends ExpensesTypeFilter {
+    _custom?: {
+        [k: string]: {
+            key?: Extract<keyof ExpensesTypeFilter, string>;
+            operator?: FilterOperator;
+            value: string | number | boolean | null | number[];
+        };
+    };
+}
+export interface ExpensesListConfig extends GenericListConfig {
+    filter?: ExpensesFilterCondition;
+}

package/dist/resources/expenses/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/resources/files/index.d.ts

@@ -0,0 +1,18 @@
+import { AbstractResource, AbstractResourceInterface } from '../../abstract';
+import { AuthInterface } from "../../types";
+import { FilesListConfig, FilesTypeCreate, FilesTypeResponse, FilesTypeUpdate } from "./types";
+export interface FilesHandler extends AbstractResourceInterface {
+    get: (id: number) => Promise<FilesTypeResponse | null>;
+    list: (config?: FilesListConfig) => Promise<FilesTypeResponse[]>;
+    create: (d: FilesTypeCreate) => Promise<FilesTypeResponse | null>;
+    update: (id: number, data: FilesTypeUpdate) => Promise<FilesTypeResponse | null>;
+    delete: (id: number) => Promise<boolean>;
+}
+export declare class Files extends AbstractResource implements FilesHandler {
+    constructor(auth: AuthInterface);
+    get: (id: number) => Promise<FilesTypeResponse | null>;
+    list: (config?: FilesListConfig) => Promise<FilesTypeResponse[]>;
+    create: (data: FilesTypeCreate) => Promise<FilesTypeResponse | null>;
+    update: (id: number, data: FilesTypeUpdate) => Promise<FilesTypeResponse | null>;
+    delete: (id: number) => Promise<boolean>;
+}

package/dist/resources/files/index.js

@@ -0,0 +1,45 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Files = void 0;
+const abstract_1 = require("../../abstract");
+class Files extends abstract_1.AbstractResource {
+    constructor(auth) {
+        super(auth, 'files');
+        this.get = (id) => __awaiter(this, void 0, void 0, function* () {
+            return (yield this.baseGet(id));
+        });
+        this.list = (...args_1) => __awaiter(this, [...args_1], void 0, function* (config = {}) {
+            const validConfig = !!config &&
+                config.filter &&
+                (config.filter.project_id ||
+                    config.filter.task_id ||
+                    config.filter.discussion_id ||
+                    config.filter.comment_id);
+            if (!validConfig) {
+                console.log('File list requires at least one valid filter condition');
+                return [];
+            }
+            return (yield this.baseList(config));
+        });
+        // Does not work yet, needs multipart upload system
+        this.create = (data) => __awaiter(this, void 0, void 0, function* () {
+            return (yield this.baseCreate(data));
+        });
+        this.update = (id, data) => __awaiter(this, void 0, void 0, function* () {
+            return (yield this.baseUpdate(id, data));
+        });
+        this.delete = (id) => __awaiter(this, void 0, void 0, function* () {
+            return yield this.baseDelete(id);
+        });
+    }
+}
+exports.Files = Files;

package/dist/resources/files/types.d.ts

@@ -0,0 +1,44 @@
+import { FilterOperator, GenericListConfig, Merge } from "../../types";
+export interface FilesTypeRead {
+    readonly id: number;
+    readonly created_on: string;
+    readonly updated_on: string;
+    readonly user_id: number | null;
+    readonly project_id: number | null;
+    readonly discussion_id: number | null;
+    readonly task_id: number | null;
+    readonly comment_id: number | null;
+    readonly token: string;
+    readonly size: number;
+    readonly mime: string;
+    readonly file: string;
+    readonly image_thumb_large?: string;
+    readonly image_thumb_medium?: string;
+    readonly image_thumb_small?: string;
+}
+export interface FilesTypeUpdate {
+    original_filename?: string;
+    description?: string;
+}
+export type FilesTypeResponse = Merge<FilesTypeUpdate, Merge<FilesTypeRead, {}>>;
+export interface FilesTypeCreate extends FilesTypeUpdate {
+}
+export interface FilesTypeFilter {
+    original_filename?: string;
+    project_id?: number;
+    discussion_id?: number;
+    task_id?: number;
+    comment_id?: number;
+}
+export interface FilesFilterCondition extends FilesTypeFilter {
+    _custom?: {
+        [k: string]: {
+            key?: Extract<keyof FilesTypeFilter, string>;
+            operator?: FilterOperator;
+            value: string | number | boolean | null | number[];
+        };
+    };
+}
+export interface FilesListConfig extends GenericListConfig {
+    filter?: FilesFilterCondition;
+}

package/dist/resources/files/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/resources/index.d.ts

@@ -0,0 +1,117 @@
+import { AuthInterface } from '../types';
+import { ProjectsHandler } from './projects';
+import { ClientsHandler } from './clients';
+import { UsersHandler } from "./users";
+import { BookingsHandler } from "./bookings";
+import { ClientContacts, ClientContactsHandler } from "./clientcontacts";
+import { Comments, CommentsHandler, Threads, ThreadsHandler } from "./comments";
+import { Company, CompanyHandler } from "./company";
+import { Discussions, DiscussionsHandler } from "./discussions";
+import { EstimateTemplates, EstimateTemplatesHandler } from "./estimatetemplates";
+import { Estimates, EstimatesHandler } from "./estimates";
+import { Expenses, ExpensesHandler } from "./expenses";
+import { Files, FilesHandler } from "./files";
+import { InvoiceTemplates, InvoiceTemplatesHandler } from "./invoicetemplates";
+import { Invoices, InvoicesHandler } from "./invoices";
+import { Milestones, MilestonesHandler } from "./milestones";
+import { ProjectTemplates, ProjectTemplatesHandler } from "./projecttemplates";
+import { ProjectStatuses, ProjectStatusesHandler } from "./projectstatuses";
+import { Reports, ReportsHandler } from "./reports";
+import { Sessions, SessionsHandler } from "./sessions";
+import { TaskLists, TaskListsHandler } from "./tasklists";
+import { Tasks, TasksHandler } from "./tasks";
+import { TimeEntries, TimeEntriesHandler } from "./entries";
+import { UserTasks, UserTasksHandler } from "./usertasks";
+import { Workflows, WorkflowsHandler } from "./workflows";
+import { WorkflowStatuses, WorkflowStatusesHandler } from "./workflowstatuses";
+export interface PaymoHandlersContainerInterface {
+    projects?: ProjectsHandler;
+    clients?: ClientsHandler;
+    users?: UsersHandler;
+    bookings?: BookingsHandler;
+    clientcontacts?: ClientContacts;
+    comments?: Comments;
+    threads?: Threads;
+    company?: Company;
+    discussions?: Discussions;
+    estimatetemplates?: EstimateTemplates;
+    estimates?: Estimates;
+    expenses?: Expenses;
+    files?: Files;
+    invoicetemplates?: InvoiceTemplates;
+    invoices?: Invoices;
+    milestones?: Milestones;
+    projecttemplates?: ProjectTemplates;
+    projectstatuses?: ProjectStatuses;
+    reports?: Reports;
+    sessions?: Sessions;
+    tasklists?: TaskLists;
+    tasks?: Tasks;
+    entries?: TimeEntries;
+    usertasks?: UserTasks;
+    workflows?: Workflows;
+    workflowstatuses?: WorkflowStatuses;
+}
+export interface PaymoResourceHandlerInterface {
+    isApiUser: (a: string) => boolean;
+    projects: () => ProjectsHandler;
+    clients: () => ClientsHandler;
+    users: () => UsersHandler;
+    bookings: () => BookingsHandler;
+    clientcontacts: () => ClientContactsHandler;
+    comments: () => CommentsHandler;
+    threads: () => ThreadsHandler;
+    company: () => CompanyHandler;
+    discussions: () => DiscussionsHandler;
+    estimatetemplates: () => EstimateTemplatesHandler;
+    estimates: () => EstimatesHandler;
+    expenses: () => ExpensesHandler;
+    files: () => FilesHandler;
+    invoicetemplates: () => InvoiceTemplatesHandler;
+    invoices: () => InvoicesHandler;
+    milestones: () => MilestonesHandler;
+    projecttemplates: () => ProjectTemplatesHandler;
+    projectstatuses: () => ProjectStatusesHandler;
+    reports: () => ReportsHandler;
+    sessions: () => SessionsHandler;
+    tasklists: () => TaskListsHandler;
+    tasks: () => TasksHandler;
+    entries: () => TimeEntriesHandler;
+    usertasks: () => UserTasksHandler;
+    workflows: () => WorkflowsHandler;
+    workflowstatuses: () => WorkflowStatusesHandler;
+}
+declare const PaymoResourceHandler: {
+    new (u: string, p: string | null): {
+        auth: AuthInterface;
+        handlers: PaymoHandlersContainerInterface;
+        isApiUser: (apiUser: string) => boolean;
+        projects: () => ProjectsHandler;
+        clients: () => ClientsHandler;
+        users: () => UsersHandler;
+        bookings: () => BookingsHandler;
+        clientcontacts: () => ClientContactsHandler;
+        comments: () => CommentsHandler;
+        threads: () => ThreadsHandler;
+        company: () => CompanyHandler;
+        discussions: () => DiscussionsHandler;
+        estimatetemplates: () => EstimateTemplatesHandler;
+        estimates: () => EstimatesHandler;
+        expenses: () => ExpensesHandler;
+        files: () => FilesHandler;
+        invoicetemplates: () => InvoiceTemplatesHandler;
+        invoices: () => InvoicesHandler;
+        milestones: () => MilestonesHandler;
+        projecttemplates: () => ProjectTemplatesHandler;
+        projectstatuses: () => ProjectStatusesHandler;
+        reports: () => ReportsHandler;
+        sessions: () => SessionsHandler;
+        tasklists: () => TaskListsHandler;
+        tasks: () => TasksHandler;
+        entries: () => TimeEntriesHandler;
+        usertasks: () => UserTasksHandler;
+        workflows: () => WorkflowsHandler;
+        workflowstatuses: () => WorkflowStatusesHandler;
+    };
+};
+export default PaymoResourceHandler;