node-paymo-api 0.0.3 → 0.0.5

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

@@ -0,0 +1,86 @@
+import { FilterOperator, GenericListConfig, Merge } from "../../types";
+export interface ProjectTypeRead {
+    readonly id: number;
+    readonly task_code_increment: number;
+    readonly created_on: string;
+    readonly updated_on: string;
+    readonly billing_type: string;
+}
+export interface ProjectTypeUpdate {
+    name?: string;
+    client_id?: number;
+    code?: string;
+    description?: string;
+    status_id?: number;
+    active?: boolean;
+    color?: string;
+    users?: number[];
+    managers?: number[];
+    billable?: boolean;
+    flat_billing?: boolean;
+    price_per_hour?: number;
+    price?: number;
+    estimated_price?: number | string;
+    hourly_billing_mode?: string;
+    budget_hours?: number;
+    adjustable_hours?: boolean;
+    invoiced?: boolean;
+    invoice_item_id?: number;
+    workflow_id?: number;
+    template_id?: number;
+    tasklists_order?: number[];
+}
+export type ProjectTypeResponse = Merge<ProjectTypeRead, Merge<ProjectTypeUpdate, {
+    description?: string | null;
+    color?: string | null;
+    price_per_hour?: number | null;
+    price?: number | null;
+    hourly_billing_mode?: string | null;
+    budget_hours?: number | null;
+    adjustable_hours?: boolean | null;
+    invoice_item_id?: number | null;
+}>>;
+export interface ProjectTypeCreate extends ProjectTypeUpdate {
+    name: string;
+    client_id: number;
+}
+export interface ProjectTypeFilter {
+    id?: number;
+    task_code_increment?: number;
+    created_on?: string;
+    updated_on?: string;
+    billing_type?: string;
+    name?: string;
+    client_id?: number;
+    code?: string;
+    description?: string | null;
+    status_id?: number;
+    active?: boolean;
+    color?: string | null;
+    users?: number | number[];
+    managers?: number | number[];
+    billable?: boolean;
+    flat_billing?: boolean;
+    price_per_hour?: number | null;
+    price?: number | null;
+    estimated_price?: number | string;
+    hourly_billing_mode?: string | null;
+    budget_hours?: number | null;
+    adjustable_hours?: boolean;
+    invoiced?: boolean;
+    invoice_item_id?: number | null;
+    workflow_id?: number;
+    template_id?: number;
+}
+export interface ProjectFilterCondition extends ProjectTypeFilter {
+    _custom?: {
+        [k: string]: {
+            key?: Extract<keyof ProjectTypeFilter, string>;
+            operator?: FilterOperator;
+            value: string | number | boolean | null | number[];
+        };
+    };
+}
+export interface ProjectsListConfig extends GenericListConfig {
+    filter?: ProjectFilterCondition;
+}

package/dist/resources/projects/types.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// export type ProjectInclude =
+//   | 'client'
+//   | ClientChildrenInclude
+//   | 'projectstatus'
+//   | 'tasklists'
+//   | 'tasks'
+//   | 'tasks.entries'
+//   | 'milestones'
+//   | 'discussions'
+//   | 'files'
+//   | 'invoiceitem'
+//   | 'workflow'

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

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

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

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

@@ -0,0 +1,32 @@
+import { FilterOperator, GenericListConfig, Merge } from "../../types";
+export interface ProjectStatusesTypeRead {
+    readonly id: number;
+    readonly created_on: string;
+    readonly updated_on: string;
+    readonly readonly: boolean;
+}
+export interface ProjectStatusesTypeUpdate {
+    name?: string;
+    active?: boolean;
+    seq?: number | null;
+}
+export type ProjectStatusesTypeResponse = Merge<ProjectStatusesTypeUpdate, Merge<ProjectStatusesTypeRead, {}>>;
+export interface ProjectStatusesTypeCreate extends ProjectStatusesTypeUpdate {
+    name: string;
+}
+export interface ProjectStatusesTypeFilter {
+    name?: string;
+    active?: boolean;
+}
+export interface ProjectStatusesFilterCondition extends ProjectStatusesTypeFilter {
+    _custom?: {
+        [k: string]: {
+            key?: Extract<keyof ProjectStatusesTypeFilter, string>;
+            operator?: FilterOperator;
+            value: string | number | boolean | null | number[];
+        };
+    };
+}
+export interface ProjectStatusesListConfig extends GenericListConfig {
+    filter?: ProjectStatusesFilterCondition;
+}

package/dist/resources/projectstatuses/types.js

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

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

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

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

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

@@ -0,0 +1,29 @@
+import { FilterOperator, GenericListConfig, Merge } from "../../types";
+export interface ProjectTemplatesTypeRead {
+    readonly id: number;
+    readonly created_on: string;
+    readonly updated_on: string;
+}
+export interface ProjectTemplatesTypeUpdate {
+    name?: string;
+}
+export type ProjectTemplatesTypeResponse = Merge<ProjectTemplatesTypeUpdate, Merge<ProjectTemplatesTypeRead, {}>>;
+export interface ProjectTemplatesTypeCreate extends ProjectTemplatesTypeUpdate {
+    name: string;
+    project_id?: number;
+}
+export interface ProjectTemplatesTypeFilter {
+    name?: string;
+}
+export interface ProjectTemplatesFilterCondition extends ProjectTemplatesTypeFilter {
+    _custom?: {
+        [k: string]: {
+            key?: Extract<keyof ProjectTemplatesTypeFilter, string>;
+            operator?: FilterOperator;
+            value: string | number | boolean | null | number[];
+        };
+    };
+}
+export interface ProjectTemplatesListConfig extends GenericListConfig {
+    filter?: ProjectTemplatesFilterCondition;
+}

package/dist/resources/projecttemplates/types.js

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

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

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

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

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

@@ -0,0 +1,90 @@
+import { FilterOperator, GenericListConfig, Merge } from "../../types";
+type ReportsDateIntervals = 'today' | 'yesterday' | 'this_month' | 'last_month' | 'this_week' | 'last_week' | 'this_year' | 'last_year' | 'all_time';
+interface ReportsIncludeOptions {
+    days?: boolean;
+    clients?: boolean;
+    users?: boolean;
+    projects?: boolean;
+    tasklists?: boolean;
+    tasks?: boolean;
+    billed?: boolean;
+    entries?: boolean;
+}
+interface ReportsExtraOptions {
+    exclude_billed_entries?: boolean;
+    exclude_unbilled_entries?: boolean;
+    exclude_billable_tasks?: boolean;
+    exclude_nonbillable_tasks?: boolean;
+    exclude_flat_rate_tasks?: boolean;
+    exclude_flats?: boolean;
+    enable_time_rounding?: boolean;
+    rounding_step?: number;
+    display_charts?: boolean;
+    display_costs?: boolean;
+    display_entries_descriptions?: boolean;
+    display_seconds?: boolean;
+    display_tasks_codes?: boolean;
+    display_tasks_descriptions?: boolean;
+    display_tasks_complete_status?: boolean;
+    display_tasks_remaining_time_budgets?: boolean;
+    display_tasks_time_budget?: boolean;
+    display_projects_budgets?: boolean;
+    display_projects_codes?: boolean;
+    display_projects_descriptions?: boolean;
+    display_projects_remaining_budgets?: boolean;
+    display_users_positions?: boolean;
+    order?: Array<keyof ReportsIncludeOptions>;
+}
+export interface ReportsTypeRead {
+    readonly id: number;
+    readonly created_on: string;
+    readonly updated_on: string;
+}
+export interface ReportsTypeUpdate {
+    name?: string;
+    user_id?: number;
+    type?: 'static' | 'live' | 'temp';
+    start_date?: string;
+    end_date?: string;
+    date_interval?: ReportsDateIntervals;
+    shared?: boolean;
+}
+export type ReportsTypeResponse = Merge<ReportsTypeUpdate, Merge<ReportsTypeRead, {
+    info: any;
+    content?: {
+        items: any[];
+    };
+    permalink: string;
+    shared: boolean;
+    share_client_id?: number;
+}>>;
+export type ReportsTypeCreate = ReportsTypeCreateWithInterval | ReportsTypeCreateWithDates;
+interface ReportsTypeCommon extends ReportsTypeUpdate {
+    projects?: number[] | 'all' | 'all_active' | 'all_archived' | string;
+    clients?: number[] | 'all' | 'all_active';
+    users?: number[] | 'all' | 'all_active' | 'all_archived';
+    include?: ReportsIncludeOptions;
+    extra?: ReportsExtraOptions;
+}
+interface ReportsTypeCreateWithInterval extends ReportsTypeCommon {
+    date_interval: ReportsDateIntervals;
+}
+interface ReportsTypeCreateWithDates extends ReportsTypeCommon {
+    start_date: string;
+    end_date: string;
+}
+export interface ReportsTypeFilter {
+}
+export interface ReportsFilterCondition extends ReportsTypeFilter {
+    _custom?: {
+        [k: string]: {
+            key?: Extract<keyof ReportsTypeFilter, string>;
+            operator?: FilterOperator;
+            value: string | number | boolean | null | number[];
+        };
+    };
+}
+export interface ReportsListConfig extends GenericListConfig {
+    filter?: ReportsFilterCondition;
+}
+export {};

package/dist/resources/reports/types.js

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

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

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

package/dist/resources/sessions/index.js

@@ -0,0 +1,35 @@
+"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.Sessions = void 0;
+const abstract_1 = require("../../abstract");
+class Sessions extends abstract_1.AbstractResource {
+    constructor(auth) {
+        super(auth, 'sessions');
+        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));
+        });
+        // There is no update method for sessions. Create, List, Get, or Delete only
+        this.update = (id, data) => __awaiter(this, void 0, void 0, function* () {
+            return null;
+        });
+        this.delete = (id) => __awaiter(this, void 0, void 0, function* () {
+            return yield this.baseDelete(id);
+        });
+    }
+}
+exports.Sessions = Sessions;

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

@@ -0,0 +1,28 @@
+import { FilterOperator, GenericListConfig, Merge } from "../../types";
+export interface SessionsTypeRead {
+    readonly id: string;
+    readonly ip: string;
+    readonly created_on: string;
+    readonly updated_on: string;
+    readonly expires_on: string;
+    readonly user_id: number;
+}
+export interface SessionsTypeUpdate {
+}
+export type SessionsTypeResponse = Merge<SessionsTypeUpdate, Merge<SessionsTypeRead, {}>>;
+export interface SessionsTypeCreate {
+}
+export interface SessionsTypeFilter {
+}
+export interface SessionsFilterCondition extends SessionsTypeFilter {
+    _custom?: {
+        [k: string]: {
+            key?: Extract<keyof SessionsTypeFilter, string>;
+            operator?: FilterOperator;
+            value: string | number | boolean | null | number[];
+        };
+    };
+}
+export interface SessionsListConfig extends GenericListConfig {
+    filter?: SessionsFilterCondition;
+}

package/dist/resources/sessions/types.js

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

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

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

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

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

@@ -0,0 +1,35 @@
+import { FilterOperator, GenericListConfig, Merge } from '../../types';
+export interface TaskListsTypeRead {
+    readonly id: number;
+    readonly created_on: string;
+    readonly updated_on: string;
+    readonly project_id: number;
+}
+export interface TaskListsTypeUpdate {
+    name?: string;
+    seq?: number | null;
+    milestone_id?: number;
+    tasks_order?: number[];
+}
+export type TaskListsTypeResponse = Merge<TaskListsTypeUpdate, Merge<TaskListsTypeRead, {}>>;
+export interface TaskListsTypeCreate extends TaskListsTypeUpdate {
+    name: string;
+    project_id: number;
+}
+export interface TaskListsTypeFilter {
+    name?: string;
+    project_id?: number;
+    milestone_id?: number;
+}
+export interface TaskListsFilterCondition extends TaskListsTypeFilter {
+    _custom?: {
+        [k: string]: {
+            key?: Extract<keyof TaskListsTypeFilter, string>;
+            operator?: FilterOperator;
+            value: string | number | boolean | null | number[];
+        };
+    };
+}
+export interface TaskListsListConfig extends GenericListConfig {
+    filter?: TaskListsFilterCondition;
+}

package/dist/resources/tasklists/types.js

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

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

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