node-paymo-api 0.0.3 → 0.0.5

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

@@ -0,0 +1,59 @@
+import { FilterOperator, GenericListConfig, Merge } from "../../types";
+export interface ClientContactsTypeRead {
+    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 ClientContactsTypeUpdate {
+    name?: string;
+    email?: string;
+    mobile?: string;
+    phone?: string;
+    fax?: string;
+    skype?: string;
+    notes?: string;
+    position?: string;
+    is_main?: boolean;
+    access?: boolean;
+    client_id?: number;
+    password?: string;
+}
+export type ClientContactsTypeResponse = Merge<ClientContactsTypeUpdate, Merge<ClientContactsTypeRead, {
+    image: string | null;
+    phone: string | null;
+    position: string | null;
+    skype: string | null;
+}>>;
+export interface ClientContactsTypeCreate extends ClientContactsTypeUpdate {
+    name: string;
+    client_id: number;
+}
+export interface ClientContactsTypeFilter {
+    id?: number;
+    created_on?: string;
+    updated_on?: string;
+    name?: string;
+    email?: string;
+    mobile?: string;
+    phone?: string;
+    fax?: string;
+    skype?: string;
+    is_main?: boolean;
+    access?: boolean;
+    client_id?: number;
+}
+export interface ClientContactsFilterCondition extends ClientContactsTypeFilter {
+    _custom?: {
+        [k: string]: {
+            key?: Extract<keyof ClientContactsTypeFilter, string>;
+            operator?: FilterOperator;
+            value: string | number | boolean | null | number[];
+        };
+    };
+}
+export interface ClientContactsListConfig extends GenericListConfig {
+    filter?: ClientContactsFilterCondition;
+}

package/dist/resources/clientcontacts/types.js

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

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

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

package/dist/resources/clients/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.Clients = void 0;
+const abstract_1 = require("../../abstract");
+class Clients extends abstract_1.AbstractResource {
+    constructor(auth) {
+        super(auth, 'clients');
+        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.Clients = Clients;

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

@@ -0,0 +1,71 @@
+import { FilterOperator, GenericListConfig, Merge } from "../../types";
+export interface ClientTypeRead {
+    readonly id: number;
+    readonly active: boolean;
+    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 ClientTypeUpdate {
+    name?: string;
+    address?: string;
+    city?: string;
+    postal_code?: string;
+    country?: string;
+    state?: string;
+    phone?: string;
+    fax?: string;
+    email?: string;
+    website?: string;
+    fiscal_information?: string;
+    image?: string;
+}
+export type ClientTypeResponse = Merge<ClientTypeRead, Merge<ClientTypeUpdate, {
+    additional_privileges: any[];
+    address?: string | null;
+    city?: string | null;
+    country?: string | null;
+    email?: string | null;
+    fax?: string | null;
+    fiscal_information?: string | null;
+    image?: string | null;
+    phone?: string | null;
+    postal_code?: string | null;
+    state?: string | null;
+    website?: string | null;
+}>>;
+export interface ClientTypeCreate extends ClientTypeUpdate {
+    name: string;
+}
+export interface ClientTypeFilter {
+    id?: number;
+    active?: boolean;
+    created_on?: string;
+    updated_on?: string;
+    name?: string;
+    address?: string | null;
+    city?: string | null;
+    country?: string | null;
+    email?: string | null;
+    fax?: string | null;
+    fiscal_information?: string | null;
+    image?: string | null;
+    phone?: string | null;
+    postal_code?: string | null;
+    state?: string | null;
+    website?: string | null;
+}
+export interface ClientFilterCondition extends ClientTypeFilter {
+    _custom?: {
+        [k: string]: {
+            key?: Extract<keyof ClientTypeFilter, string>;
+            operator?: FilterOperator;
+            value: string | number | boolean | null | number[];
+        };
+    };
+}
+export interface ClientsListConfig extends GenericListConfig {
+    filter?: ClientFilterCondition;
+}

package/dist/resources/clients/types.js

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

package/dist/resources/comments/Comments.d.ts

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

package/dist/resources/comments/Comments.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.Comments = void 0;
+const abstract_1 = require("../../abstract");
+class Comments extends abstract_1.AbstractResource {
+    constructor(auth) {
+        super(auth, 'comments');
+        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.Comments = Comments;

package/dist/resources/comments/Threads.d.ts

@@ -0,0 +1,28 @@
+import { AbstractResource, AbstractResourceInterface } from '../../abstract';
+import { AuthInterface } from "../../types";
+import { ThreadsListConfig, ThreadsTypeResponse } from "./types";
+export interface ThreadsHandler extends AbstractResourceInterface {
+    get: (id: number) => Promise<ThreadsTypeResponse | null>;
+    list: (config?: ThreadsListConfig) => Promise<ThreadsTypeResponse[]>;
+}
+export declare class Threads extends AbstractResource implements ThreadsHandler {
+    constructor(auth: AuthInterface);
+    get: (id: number) => Promise<{
+        readonly id: number;
+        readonly created_on: string;
+        readonly updated_on: string;
+        readonly task_id: number | null;
+        readonly project_id: number;
+        readonly discussion_id: number | null;
+        readonly file_id: number | null;
+    } | null>;
+    list: (config?: ThreadsListConfig) => Promise<{
+        readonly id: number;
+        readonly created_on: string;
+        readonly updated_on: string;
+        readonly task_id: number | null;
+        readonly project_id: number;
+        readonly discussion_id: number | null;
+        readonly file_id: number | null;
+    }[]>;
+}

package/dist/resources/comments/Threads.js

@@ -0,0 +1,25 @@
+"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.Threads = void 0;
+const abstract_1 = require("../../abstract");
+class Threads extends abstract_1.AbstractResource {
+    constructor(auth) {
+        super(auth, 'threads');
+        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));
+        });
+    }
+}
+exports.Threads = Threads;

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

@@ -0,0 +1,2 @@
+export { Comments, CommentsHandler } from './Comments';
+export { Threads, ThreadsHandler } from './Threads';

package/dist/resources/comments/index.js

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

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

@@ -0,0 +1,77 @@
+import { FilterOperator, GenericListConfig, Merge } from '../../types';
+export interface CommentsTypeRead {
+    readonly id: number;
+    readonly created_on: string;
+    readonly updated_on: string;
+    readonly thread_id: number;
+    readonly user_id: number;
+}
+export interface CommentsTypeUpdate {
+    content: string;
+}
+export type CommentsTypeResponse = Merge<CommentsTypeUpdate, Merge<CommentsTypeRead, {}>>;
+interface CommentsTypeCreateWithThread extends CommentsTypeUpdate {
+    thread_id: number;
+}
+interface CommentsTypeCreateWithTask extends CommentsTypeUpdate {
+    task_id: number;
+}
+interface CommentsTypeCreateWithDiscussion extends CommentsTypeUpdate {
+    discussion_id: number;
+}
+interface CommentsTypeCreateWithFile extends CommentsTypeUpdate {
+    file_id: number;
+}
+export type CommentsTypeCreate = CommentsTypeCreateWithThread | CommentsTypeCreateWithTask | CommentsTypeCreateWithDiscussion | CommentsTypeCreateWithFile;
+export interface CommentsTypeFilter {
+    id?: number;
+    thread_id?: number;
+    user_id?: number;
+    created_on?: string;
+    updated_on?: string;
+    content?: string;
+}
+export interface CommentsFilterCondition extends CommentsTypeFilter {
+    _custom?: {
+        [k: string]: {
+            key?: Extract<keyof CommentsTypeFilter, string>;
+            operator?: FilterOperator;
+            value: string | number | boolean | null | number[];
+        };
+    };
+}
+export interface CommentsListConfig extends GenericListConfig {
+    filter?: CommentsFilterCondition;
+}
+export interface ThreadsTypeRead {
+    readonly id: number;
+    readonly created_on: string;
+    readonly updated_on: string;
+    readonly project_id: number;
+    readonly discussion_id: number | null;
+    readonly task_id: number | null;
+    readonly file_id: number | null;
+}
+export type ThreadsTypeResponse = Merge<ThreadsTypeRead, {}>;
+export interface ThreadsTypeFilter {
+    id?: number;
+    created_on?: string;
+    updated_on?: string;
+    project_id?: number;
+    discussion_id?: number;
+    task_id?: number;
+    file_id?: number;
+}
+export interface ThreadsFilterCondition extends ThreadsTypeFilter {
+    _custom?: {
+        [k: string]: {
+            key?: Extract<keyof ThreadsTypeFilter, string>;
+            operator?: FilterOperator;
+            value: string | number | boolean | null | number[];
+        };
+    };
+}
+export interface ThreadsListConfig extends GenericListConfig {
+    filter?: ThreadsFilterCondition;
+}
+export {};

package/dist/resources/comments/types.js

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

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

@@ -0,0 +1,12 @@
+import { AbstractResource, AbstractResourceInterface } from '../../abstract';
+import { AuthInterface } from "../../types";
+import { CompanyTypeResponse, CompanyTypeUpdate } from "./types";
+export interface CompanyHandler extends AbstractResourceInterface {
+    get: () => Promise<CompanyTypeResponse | null>;
+    update: (data: CompanyTypeUpdate) => Promise<CompanyTypeResponse | null>;
+}
+export declare class Company extends AbstractResource implements CompanyHandler {
+    constructor(auth: AuthInterface);
+    get: () => Promise<CompanyTypeResponse | null>;
+    update: (data: CompanyTypeUpdate) => Promise<CompanyTypeResponse | null>;
+}

package/dist/resources/company/index.js

@@ -0,0 +1,25 @@
+"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.Company = void 0;
+const abstract_1 = require("../../abstract");
+class Company extends abstract_1.AbstractResource {
+    constructor(auth) {
+        super(auth, 'company');
+        this.get = () => __awaiter(this, void 0, void 0, function* () {
+            return (yield this.baseGet(null));
+        });
+        this.update = (data) => __awaiter(this, void 0, void 0, function* () {
+            return (yield this.baseUpdate(null, data));
+        });
+    }
+}
+exports.Company = Company;

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

@@ -0,0 +1,44 @@
+import { Merge } from "../../types";
+export interface CompanyTypeRead {
+    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;
+    readonly account_type: string;
+    readonly max_users: number;
+    readonly current_users: number;
+    readonly max_projects: number | null;
+    readonly current_projects: number;
+    readonly max_invoices: number;
+    readonly current_invoices: number;
+}
+export interface CompanyTypeUpdate {
+    name?: string;
+    address?: string;
+    phone?: string;
+    email?: string;
+    url?: string;
+    fiscal_information?: string;
+    country?: string;
+    image?: string;
+    timezone?: string;
+    default_currency?: string;
+    default_price_per_hour?: string;
+    apply_tax_to_expenses?: string;
+    tax_on_tax?: string;
+    currency_position?: "left" | "right";
+    next_invoice_number?: number;
+    next_estimate_number?: number;
+    online_payments?: number;
+    date_format?: "Y-m-d" | "d/m/Y" | "m/d/Y" | "d.m.Y";
+    time_format?: "H:i" | "h:i";
+    decimal_sep?: string;
+    thousands_sep?: string;
+    week_start?: "0" | "1" | "2" | "3" | "4" | "5" | "6";
+    workday_start?: string;
+    workday_end?: string;
+    working_days?: string;
+}
+export type CompanyTypeResponse = Merge<CompanyTypeUpdate, Merge<CompanyTypeRead, {}>>;

package/dist/resources/company/types.js

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

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

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

package/dist/resources/discussions/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.Discussions = void 0;
+const abstract_1 = require("../../abstract");
+class Discussions extends abstract_1.AbstractResource {
+    constructor(auth) {
+        super(auth, 'discussions');
+        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.Discussions = Discussions;

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

@@ -0,0 +1,43 @@
+import { FilterOperator, GenericListConfig, Merge } from "../../types";
+export interface DiscussionsTypeRead {
+    readonly id: number;
+    readonly created_on: string;
+    readonly updated_on: string;
+}
+export interface DiscussionsTypeUpdate {
+    name?: string;
+    description?: string;
+    project_id?: number;
+    user_id?: number;
+}
+export type DiscussionsTypeResponse = Merge<DiscussionsTypeUpdate, Merge<DiscussionsTypeRead, {
+    name: string;
+    project_id: number;
+    description: string | null;
+    user_id: number;
+    comments_count: number;
+}>>;
+export interface DiscussionsTypeCreate extends DiscussionsTypeUpdate {
+    name: string;
+    project_id: number;
+}
+export interface DiscussionsTypeFilter {
+    id?: number;
+    created_on?: string;
+    updated_on?: string;
+    name?: string;
+    description?: string;
+    user_id?: number;
+}
+export interface DiscussionsFilterCondition extends DiscussionsTypeFilter {
+    _custom?: {
+        [k: string]: {
+            key?: Extract<keyof DiscussionsTypeFilter, string>;
+            operator?: FilterOperator;
+            value: string | number | boolean | null | number[];
+        };
+    };
+}
+export interface DiscussionsListConfig extends GenericListConfig {
+    filter?: DiscussionsFilterCondition;
+}

package/dist/resources/discussions/types.js

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

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

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

package/dist/resources/entries/index.js

@@ -0,0 +1,47 @@
+"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.TimeEntries = void 0;
+const abstract_1 = require("../../abstract");
+class TimeEntries extends abstract_1.AbstractResource {
+    constructor(auth) {
+        super(auth, 'entries');
+        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.client_id ||
+                    config.filter.task_id ||
+                    config.filter.user_id ||
+                    (config.filter.time_interval &&
+                        Array.isArray(config.filter.time_interval) &&
+                        config.filter.time_interval.length === 2));
+            if (!validConfig) {
+                console.log('Entry list requires at least one valid filter condition');
+                return [];
+            }
+            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.TimeEntries = TimeEntries;