rotacloud 1.5.2 → 2.0.1

package/dist/mjs/services/pins.service.js

@@ -1,12 +0,0 @@
-import { Service } from './index.js';
-export class PinsService extends Service {
-    constructor() {
-        super(...arguments);
-        this.apiPath = '/pins';
-    }
-    get(id, options) {
-        return super
-            .fetch({ url: `${this.apiPath}/${id}` }, options)
-            .then((res) => (options?.rawResponse ? res : res.data));
-    }
-}

package/dist/mjs/services/roles.service.d.ts

@@ -1,51 +0,0 @@
-import { AxiosResponse } from 'axios';
-import { Role } from '../interfaces/index.js';
-import { Service, Options, RequirementsOf, OptionsExtended } from './index.js';
-import { RolesQueryParams } from '../interfaces/query-params/roles-query-params.interface.js';
-type RequiredProps = 'name';
-export declare class RolesService extends Service<Role> {
-    private apiPath;
-    create(data: RequirementsOf<Role, RequiredProps>): Promise<Role>;
-    create(data: RequirementsOf<Role, RequiredProps>, options: {
-        rawResponse: true;
-    } & Options): Promise<AxiosResponse<Role, any>>;
-    create(data: RequirementsOf<Role, RequiredProps>, options: Options): Promise<Role>;
-    get(id: number): Promise<Role>;
-    get<F extends keyof Role>(id: number, options: {
-        fields: F[];
-        rawResponse: true;
-    } & OptionsExtended<Role>): Promise<AxiosResponse<Pick<Role, F>>>;
-    get<F extends keyof Role>(id: number, options: {
-        fields: F[];
-    } & OptionsExtended<Role>): Promise<Pick<Role, F>>;
-    get(id: number, options: {
-        rawResponse: true;
-    } & Options): Promise<AxiosResponse<Role>>;
-    get(id: number, options?: OptionsExtended<Role>): Promise<Role>;
-    list(query?: RolesQueryParams): AsyncGenerator<Role>;
-    list<F extends keyof Role>(query: RolesQueryParams, options: {
-        fields: F[];
-    } & OptionsExtended<Role>): AsyncGenerator<Pick<Role, F>>;
-    list(query?: RolesQueryParams, options?: OptionsExtended<Role>): AsyncGenerator<Role>;
-    listAll(query?: RolesQueryParams): Promise<Role[]>;
-    listAll<F extends keyof Role>(query: RolesQueryParams, options: {
-        fields: F[];
-    } & OptionsExtended<Role>): Promise<Pick<Role, F>[]>;
-    listAll(query?: RolesQueryParams, options?: OptionsExtended<Role>): Promise<Role[]>;
-    listByPage(query?: RolesQueryParams): AsyncGenerator<AxiosResponse<Role[]>>;
-    listByPage<F extends keyof Role>(query: RolesQueryParams, options: {
-        fields: F[];
-    } & OptionsExtended<Role>): AsyncGenerator<AxiosResponse<Pick<Role, F>[]>>;
-    listByPage(query?: RolesQueryParams, options?: OptionsExtended<Role>): AsyncGenerator<AxiosResponse<Role[]>>;
-    update(id: number, data: Partial<Role>): Promise<Role>;
-    update(id: number, data: Partial<Role>, options: {
-        rawResponse: true;
-    } & Options): Promise<AxiosResponse<Role, any>>;
-    update(id: number, data: Partial<Role>, options: Options): Promise<Role>;
-    delete(id: number): Promise<number>;
-    delete(id: number, options: {
-        rawResponse: true;
-    } & Options): Promise<AxiosResponse<void>>;
-    delete(id: number, options: Options): Promise<number>;
-}
-export {};

package/dist/mjs/services/roles.service.js

@@ -1,44 +0,0 @@
-import { Service } from './index.js';
-export class RolesService extends Service {
-    constructor() {
-        super(...arguments);
-        this.apiPath = '/roles';
-    }
-    create(data, options) {
-        return super
-            .fetch({ url: this.apiPath, data, method: 'POST' }, options)
-            .then((res) => (options?.rawResponse ? res : res.data));
-    }
-    get(id, options) {
-        return super
-            .fetch({ url: `${this.apiPath}/${id}` }, options)
-            .then((res) => (options?.rawResponse ? res : res.data));
-    }
-    async *list(query, options) {
-        yield* super.iterator({ url: this.apiPath, params: query }, options);
-    }
-    async listAll(query, options) {
-        const roles = [];
-        for await (const role of this.list(query, options)) {
-            roles.push(role);
-        }
-        return roles;
-    }
-    listByPage(query, options) {
-        return super.iterator({ url: this.apiPath, params: query }, options).byPage();
-    }
-    update(id, data, options) {
-        return super
-            .fetch({
-            url: `${this.apiPath}/${id}`,
-            data,
-            method: 'POST',
-        }, options)
-            .then((res) => (options?.rawResponse ? res : res.data));
-    }
-    delete(id, options) {
-        return super
-            .fetch({ url: `${this.apiPath}/${id}`, method: 'DELETE' }, options)
-            .then((res) => (options?.rawResponse ? res : res.status));
-    }
-}

package/dist/mjs/services/service.d.ts

@@ -1,47 +0,0 @@
-import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
-import { SDKConfig } from '../interfaces';
-export type RequirementsOf<T, K extends keyof T> = Required<Pick<T, K>> & Partial<T>;
-export type Options = {
-    rawResponse?: boolean;
-    maxResults?: number;
-    limit?: never;
-    offset?: number;
-    dryRun?: boolean;
-} | {
-    rawResponse?: boolean;
-    maxResults?: never;
-    /** @deprecated use `maxResults` instead */
-    limit?: number;
-    offset?: number;
-    dryRun?: boolean;
-};
-export type OptionsExtended<T = unknown> = Options & {
-    fields?: (keyof T)[];
-};
-export declare abstract class Service<ApiResponse = any> {
-    protected client: AxiosInstance;
-    protected readonly options: {
-        config: SDKConfig;
-    };
-    constructor(client: AxiosInstance, options: {
-        config: SDKConfig;
-    });
-    private isLeaveRequest;
-    private buildQueryParams;
-    fetch<T = ApiResponse>(reqConfig: AxiosRequestConfig): Promise<AxiosResponse<T>>;
-    fetch<T = ApiResponse>(reqConfig: AxiosRequestConfig, options: {
-        fields: Required<OptionsExtended<T>>['fields'];
-    } & OptionsExtended<T>): Promise<AxiosResponse<Pick<T, (typeof options)['fields'][number]>>>;
-    fetch<T extends unknown[] = ApiResponse[], E = T[number]>(reqConfig: AxiosRequestConfig, options: {
-        fields: Required<OptionsExtended<E>>['fields'];
-    } & OptionsExtended<E>): Promise<AxiosResponse<Pick<E, (typeof options)['fields'][number]>[]>>;
-    fetch<T extends unknown[] = ApiResponse[]>(reqConfig: AxiosRequestConfig, options?: Options): Promise<AxiosResponse<T>>;
-    fetch<T = ApiResponse>(reqConfig: AxiosRequestConfig, options?: Options): Promise<AxiosResponse<T | Partial<T>>>;
-    /** Iterates through every page for a potentially paginated request */
-    private fetchPages;
-    private listResponses;
-    iterator<T = ApiResponse>(reqConfig: AxiosRequestConfig<T[]>, options?: Options): {
-        [Symbol.asyncIterator]: () => AsyncGenerator<Awaited<T>, void, undefined>;
-        byPage: () => AsyncGenerator<AxiosResponse<T[], any>, any, unknown>;
-    };
-}

package/dist/mjs/services/service.js

@@ -1,101 +0,0 @@
-import { Version } from '../version.js';
-export class Service {
-    constructor(client, 
-    // opt to use options object here, so we could
-    // define the config property as a getter
-    // in RotaCloud class. With this change config in
-    // this class will always be up-to-date with
-    // RotaCloud client config
-    options) {
-        this.client = client;
-        this.options = options;
-    }
-    isLeaveRequest(endpoint) {
-        return endpoint === '/leave_requests';
-    }
-    buildQueryParams(options, extraParams) {
-        const queryParams = {
-            fields: options?.fields,
-            limit: options?.maxResults ?? options?.limit,
-            offset: options?.offset,
-            dry_run: options?.dryRun,
-            ...extraParams,
-            // NOTE: Should not overridable so must come after spread of params
-            exclude_link_header: true,
-        };
-        const reducedParams = Object.entries(queryParams ?? {}).reduce((params, [key, val]) => {
-            if (val !== undefined && val !== '') {
-                if (Array.isArray(val))
-                    params.push(...val.map((item) => [`${key}[]`, String(item)]));
-                else
-                    params.push([key, String(val)]);
-            }
-            return params;
-        }, []);
-        return new URLSearchParams(reducedParams);
-    }
-    fetch(reqConfig, options) {
-        const headers = {
-            Authorization: this.options.config.apiKey
-                ? `Bearer ${this.options.config.apiKey}`
-                : `Basic ${this.options.config.basicAuth}`,
-            'SDK-Version': Version.version,
-        };
-        const extraHeaders = this.options.config.headers;
-        if (extraHeaders && typeof extraHeaders === 'object') {
-            for (const [key, val] of Object.entries(extraHeaders)) {
-                if (typeof key === 'string' && typeof val === 'string') {
-                    headers[key] = val;
-                }
-            }
-        }
-        if (this.options.config.accountId) {
-            headers.Account = String(this.options.config.accountId);
-        }
-        else {
-            // need to convert user field in payload to a header for creating leave_requests when using an API key
-            this.isLeaveRequest(reqConfig.url) ? (headers.User = `${reqConfig.data.user}`) : undefined;
-        }
-        const finalReqConfig = {
-            ...reqConfig,
-            baseURL: this.options.config.baseUri,
-            headers,
-            params: this.buildQueryParams(options, reqConfig.params),
-        };
-        return this.client.request(finalReqConfig);
-    }
-    async *fetchPages(reqConfig, options) {
-        const fallbackLimit = 20;
-        const res = await this.fetch(reqConfig, options);
-        yield res;
-        const limit = Number(res.headers['x-limit']) || fallbackLimit;
-        const entityCount = Number(res.headers['x-total-count']) || 0;
-        const requestOffset = Number(res.headers['x-offset']) || 0;
-        for (let offset = requestOffset + limit; offset < entityCount; offset += limit) {
-            yield this.fetch(reqConfig, { ...options, offset });
-        }
-    }
-    async *listResponses(reqConfig, options) {
-        if (!options?.maxResults) {
-            for await (const res of this.fetchPages(reqConfig, options)) {
-                yield* res.data;
-            }
-            return;
-        }
-        let entityCount = 0;
-        for await (const res of this.fetchPages(reqConfig, options)) {
-            for (const entity of res.data) {
-                yield entity;
-                entityCount += 1;
-                if (entityCount >= options.maxResults)
-                    return;
-            }
-        }
-    }
-    iterator(reqConfig, options) {
-        return {
-            [Symbol.asyncIterator]: () => this.listResponses(reqConfig, options),
-            byPage: () => this.fetchPages(reqConfig, options),
-        };
-    }
-}

package/dist/mjs/services/settings.service.d.ts

@@ -1,12 +0,0 @@
-import { AxiosResponse } from 'axios';
-import { Service, Options } from './index.js';
-import { Settings } from '../interfaces/index.js';
-import { SettingsQueryParams } from '../rotacloud.js';
-export declare class SettingsService extends Service<Settings> {
-    private apiPath;
-    get(query: SettingsQueryParams): Promise<Settings>;
-    get(query: SettingsQueryParams, options: {
-        rawResponse: true;
-    } & Options): Promise<AxiosResponse<Settings, any>>;
-    get(query: SettingsQueryParams, options: Options): Promise<Settings>;
-}

package/dist/mjs/services/settings.service.js

@@ -1,12 +0,0 @@
-import { Service } from './index.js';
-export class SettingsService extends Service {
-    constructor() {
-        super(...arguments);
-        this.apiPath = '/settings';
-    }
-    get(query, options) {
-        return super
-            .fetch({ url: `${this.apiPath}`, params: query }, options)
-            .then((res) => (options?.rawResponse ? res : res.data));
-    }
-}

package/dist/mjs/services/shifts.service.d.ts

@@ -1,120 +0,0 @@
-import { AxiosResponse } from 'axios';
-import { Shift } from '../interfaces/index.js';
-import { Options, OptionsExtended, RequirementsOf, Service } from './index.js';
-import { ShiftDropRequest } from '../interfaces/drop-request.interface.js';
-import { ShiftsQueryParams } from '../interfaces/query-params/shifts-query-params.interface.js';
-import { ShiftSwapRequest } from '../interfaces/swap-request.interface.js';
-type RequiredProps = 'end_time' | 'start_time' | 'location';
-export declare class ShiftsService extends Service<Shift> {
-    private apiPath;
-    create(data: RequirementsOf<Shift, RequiredProps>): Promise<Shift>;
-    create(data: RequirementsOf<Shift, RequiredProps>, options: {
-        rawResponse: true;
-    } & Options): Promise<AxiosResponse<Shift, any>>;
-    create(data: RequirementsOf<Shift, RequiredProps>, options: Options): Promise<Shift>;
-    get(id: number): Promise<Shift>;
-    get<F extends keyof Shift>(id: number, options: {
-        fields: F[];
-        rawResponse: true;
-    } & OptionsExtended<Shift>): Promise<AxiosResponse<Pick<Shift, F>>>;
-    get<F extends keyof Shift>(id: number, options: {
-        fields: F[];
-    } & OptionsExtended<Shift>): Promise<Pick<Shift, F>>;
-    get(id: number, options: {
-        rawResponse: true;
-    } & Options): Promise<AxiosResponse<Shift>>;
-    get(id: number, options?: OptionsExtended<Shift>): Promise<Shift>;
-    list(query: ShiftsQueryParams): AsyncGenerator<Shift>;
-    list<F extends keyof Shift>(query: ShiftsQueryParams, options: {
-        fields: F[];
-    } & OptionsExtended<Shift>): AsyncGenerator<Pick<Shift, F>>;
-    list(query: ShiftsQueryParams, options?: OptionsExtended<Shift>): AsyncGenerator<Shift>;
-    listAll(query: ShiftsQueryParams): Promise<Shift[]>;
-    listAll<F extends keyof Shift>(query: ShiftsQueryParams, options: {
-        fields: F[];
-    } & OptionsExtended<Shift>): Promise<Pick<Shift, F>[]>;
-    listAll(query: ShiftsQueryParams, options?: OptionsExtended<Shift>): Promise<Shift[]>;
-    listByPage(query: ShiftsQueryParams): AsyncGenerator<AxiosResponse<Shift[]>>;
-    listByPage<F extends keyof Shift>(query: ShiftsQueryParams, options: {
-        fields: F[];
-    } & OptionsExtended<Shift>): AsyncGenerator<AxiosResponse<Pick<Shift, F>[]>>;
-    listByPage(query: ShiftsQueryParams, options?: OptionsExtended<Shift>): AsyncGenerator<AxiosResponse<Shift[]>>;
-    update(shift: RequirementsOf<Shift, 'id'>): Promise<Shift>;
-    update(shift: RequirementsOf<Shift, 'id'>, options: {
-        rawResponse: true;
-    } & Options): Promise<AxiosResponse<Shift>>;
-    update(shift: RequirementsOf<Shift, 'id'>, options: Options): Promise<Shift>;
-    update(shifts: RequirementsOf<Shift, 'id'>[]): Promise<{
-        success: Shift[];
-        failed: {
-            id: number;
-            error: string;
-        }[];
-    }>;
-    update(shifts: RequirementsOf<Shift, 'id'>[], options: {
-        rawResponse: true;
-    } & Options): Promise<AxiosResponse<{
-        code: number;
-        data?: Shift;
-        error?: string;
-    }[]>>;
-    update(shifts: RequirementsOf<Shift, 'id'>[], options: Options): Promise<{
-        success: Shift[];
-        failed: {
-            id: number;
-            error: string;
-        }[];
-    }>;
-    delete(ids: number | number[]): Promise<number>;
-    delete(ids: number | number[], options: {
-        rawResponse: true;
-    } & Options): Promise<AxiosResponse<void>>;
-    delete(ids: number | number[], options: Options): Promise<number>;
-    acknowledge(shifts: number[]): Promise<number>;
-    acknowledge(shifts: number[], options: {
-        rawResponse: true;
-    } & Options): Promise<AxiosResponse<any>>;
-    acknowledge(shifts: number[], options: Options): Promise<number>;
-    publish(data: {
-        shifts: number[];
-    }): Promise<number>;
-    publish(data: {
-        shifts: number[];
-    }, options: {
-        rawResponse: true;
-    } & Options): Promise<AxiosResponse<any>>;
-    publish(data: {
-        shifts: number[];
-    }, options: Options): Promise<number>;
-    unpublish(data: {
-        shifts: number[];
-    }): Promise<number>;
-    unpublish(data: {
-        shifts: number[];
-    }, options: {
-        rawResponse: true;
-    } & Options): Promise<AxiosResponse<any>>;
-    unpublish(data: {
-        shifts: number[];
-    }, options: Options): Promise<number>;
-    updateSwap(data: ShiftSwapRequest): Promise<ShiftSwapRequest>;
-    updateSwap(data: ShiftSwapRequest, options: {
-        rawResponse: true;
-    } & Options): Promise<AxiosResponse<ShiftSwapRequest>>;
-    updateSwap(data: ShiftSwapRequest, options: Options): Promise<ShiftSwapRequest>;
-    updateDrop(data: {
-        request: RequirementsOf<ShiftDropRequest, 'id' | 'user_message'>;
-        approved: boolean;
-    }): Promise<ShiftDropRequest>;
-    updateDrop(data: {
-        request: RequirementsOf<ShiftDropRequest, 'id' | 'user_message'>;
-        approved: boolean;
-    }, options: {
-        rawResponse: true;
-    } & Options): Promise<AxiosResponse<ShiftDropRequest>>;
-    updateDrop(data: {
-        request: RequirementsOf<ShiftDropRequest, 'id' | 'user_message'>;
-        approved: boolean;
-    }, options: Options): Promise<ShiftDropRequest>;
-}
-export {};

package/dist/mjs/services/shifts.service.js

@@ -1,96 +0,0 @@
-import { Service } from './index.js';
-export class ShiftsService extends Service {
-    constructor() {
-        super(...arguments);
-        this.apiPath = '/shifts';
-    }
-    create(data, options) {
-        return super
-            .fetch({ url: this.apiPath, data, method: 'POST' }, options)
-            .then((res) => (options?.rawResponse ? res : res.data));
-    }
-    get(id, options) {
-        return super
-            .fetch({ url: `${this.apiPath}/${id}` }, options)
-            .then((res) => (options?.rawResponse ? res : res.data));
-    }
-    async *list(query, options) {
-        yield* super.iterator({ url: this.apiPath, params: query }, options);
-    }
-    async listAll(query, options) {
-        const shifts = [];
-        for await (const shift of this.list(query, options)) {
-            shifts.push(shift);
-        }
-        return shifts;
-    }
-    listByPage(query, options) {
-        return super.iterator({ url: this.apiPath, params: query }, options).byPage();
-    }
-    update(shifts, options) {
-        if (!Array.isArray(shifts)) {
-            return super
-                .fetch({
-                url: `${this.apiPath}/${shifts.id}`,
-                data: shifts,
-                method: 'POST',
-            }, options)
-                .then((res) => (options?.rawResponse ? res : res.data));
-        }
-        return super
-            .fetch({
-            url: this.apiPath,
-            data: shifts,
-            method: 'POST',
-        }, options)
-            .then((res) => {
-            if (options?.rawResponse)
-                return res;
-            const success = [];
-            const failed = [];
-            for (let shiftIdx = 0; shiftIdx < res.data.length; shiftIdx += 1) {
-                const { data, error } = res.data[shiftIdx];
-                if (data)
-                    success.push(data);
-                if (error)
-                    failed.push({ id: shifts[shiftIdx].id, error });
-            }
-            return { success, failed };
-        });
-    }
-    delete(ids, options) {
-        const params = Array.isArray(ids)
-            ? { url: this.apiPath, data: { ids }, method: 'DELETE' }
-            : { url: `${this.apiPath}/${ids}`, method: 'DELETE' };
-        return super.fetch(params, options).then((res) => (options?.rawResponse ? res : res.status));
-    }
-    acknowledge(shifts, options) {
-        return super
-            .fetch({ url: '/shifts_acknowledged', data: { shifts }, method: 'POST' }, options)
-            .then((res) => (options?.rawResponse ? res : res.status));
-    }
-    publish(data, options) {
-        return super
-            .fetch({ url: '/shifts_published', data, method: 'POST' }, options)
-            .then((res) => (options?.rawResponse ? res : res.status));
-    }
-    unpublish(data, options) {
-        return super
-            .fetch({ url: '/shifts_published', data, method: 'DELETE' }, options)
-            .then((res) => (options?.rawResponse ? res : res.status));
-    }
-    updateSwap(data, options) {
-        return super
-            .fetch({ url: `/swap_requests/${data.id}`, data, method: 'POST' }, options)
-            .then((res) => (options?.rawResponse ? res : res.data));
-    }
-    updateDrop(data, options) {
-        return super
-            .fetch({
-            url: `/unavailability_requests/${data.request.id}/${data.approved ? 'approve' : 'deny'}`,
-            data: { message: data.request.user_message },
-            method: 'POST',
-        }, options)
-            .then((res) => (options?.rawResponse ? res : res.data));
-    }
-}

package/dist/mjs/services/terminals-active.service.d.ts

@@ -1,46 +0,0 @@
-import { AxiosResponse } from 'axios';
-import { Terminal, TerminalLocation } from '../interfaces/index.js';
-import { Service, Options, OptionsExtended } from './index.js';
-interface LaunchTerminal {
-    terminal: number;
-    device: string;
-    location?: TerminalLocation;
-}
-interface PingTerminal {
-    action: string;
-    device: string;
-}
-export declare class TerminalsActiveService extends Service<Terminal> {
-    private apiPath;
-    launchTerminal(data: LaunchTerminal): Promise<Terminal>;
-    launchTerminal(data: LaunchTerminal, options: {
-        rawResponse: true;
-    } & Options): Promise<AxiosResponse<Terminal>>;
-    launchTerminal(data: LaunchTerminal, options: Options): Promise<Terminal>;
-    pingTerminal(id: number, data: PingTerminal): Promise<number>;
-    pingTerminal(id: number, data: PingTerminal, options: {
-        rawResponse: true;
-    } & Options): Promise<AxiosResponse<number>>;
-    pingTerminal(id: number, data: PingTerminal, options: Options): Promise<number>;
-    list(): AsyncGenerator<Terminal>;
-    list<F extends keyof Terminal>(options: {
-        fields: F[];
-    } & OptionsExtended<Terminal>): AsyncGenerator<Pick<Terminal, F>>;
-    list(options?: OptionsExtended<Terminal>): AsyncGenerator<Terminal>;
-    listAll(): Promise<Terminal[]>;
-    listAll<F extends keyof Terminal>(options: {
-        fields: F[];
-    } & OptionsExtended<Terminal>): Promise<Pick<Terminal, F>[]>;
-    listAll(options?: OptionsExtended<Terminal>): Promise<Terminal[]>;
-    listByPage(): AsyncGenerator<AxiosResponse<Terminal[]>>;
-    listByPage<F extends keyof Terminal>(options: {
-        fields: F[];
-    } & OptionsExtended<Terminal>): AsyncGenerator<AxiosResponse<Pick<Terminal, F>[]>>;
-    listByPage(options?: OptionsExtended<Terminal>): AsyncGenerator<AxiosResponse<Terminal[]>>;
-    closeTerminal(id: number): Promise<number>;
-    closeTerminal(id: number, options: {
-        rawResponse: true;
-    } & Options): Promise<AxiosResponse<void>>;
-    closeTerminal(id: number, options: Options): Promise<number>;
-}
-export {};

package/dist/mjs/services/terminals-active.service.js

@@ -1,39 +0,0 @@
-import { Service } from './index.js';
-export class TerminalsActiveService extends Service {
-    constructor() {
-        super(...arguments);
-        this.apiPath = '/terminals_active';
-    }
-    launchTerminal(data, options) {
-        return super
-            .fetch({
-            url: this.apiPath,
-            data,
-            method: 'POST',
-        }, options)
-            .then((res) => (options?.rawResponse ? res : res.data));
-    }
-    pingTerminal(id, data, options) {
-        return super
-            .fetch({ url: `${this.apiPath}/${id}`, data, method: 'POST' }, options)
-            .then((res) => (options?.rawResponse ? res : res.data));
-    }
-    async *list(options) {
-        yield* super.iterator({ url: this.apiPath }, options);
-    }
-    async listAll(options) {
-        const users = [];
-        for await (const user of this.list(options)) {
-            users.push(user);
-        }
-        return users;
-    }
-    listByPage(options) {
-        return super.iterator({ url: this.apiPath }, options).byPage();
-    }
-    closeTerminal(id, options) {
-        return super
-            .fetch({ url: `${this.apiPath}/${id}`, method: 'DELETE' }, options)
-            .then((res) => (options?.rawResponse ? res : res.status));
-    }
-}

package/dist/mjs/services/terminals.service.d.ts

@@ -1,50 +0,0 @@
-import { AxiosResponse } from 'axios';
-import { Terminal } from '../interfaces/index.js';
-import { Service, Options, RequirementsOf, OptionsExtended } from './index.js';
-type RequiredProps = 'name' | 'timezone';
-export declare class TerminalsService extends Service<Terminal> {
-    private apiPath;
-    create(data: RequirementsOf<Terminal, RequiredProps>): Promise<Terminal>;
-    create(data: RequirementsOf<Terminal, RequiredProps>, options: {
-        rawResponse: true;
-    } & Options): Promise<AxiosResponse<Terminal, any>>;
-    create(data: RequirementsOf<Terminal, RequiredProps>, options: Options): Promise<Terminal>;
-    get(id: number): Promise<Terminal>;
-    get<F extends keyof Terminal>(id: number, options: {
-        fields: F[];
-        rawResponse: true;
-    } & OptionsExtended<Terminal>): Promise<AxiosResponse<Pick<Terminal, F>>>;
-    get<F extends keyof Terminal>(id: number, options: {
-        fields: F[];
-    } & OptionsExtended<Terminal>): Promise<Pick<Terminal, F>>;
-    get(id: number, options: {
-        rawResponse: true;
-    } & Options): Promise<AxiosResponse<Terminal>>;
-    get(id: number, options?: OptionsExtended<Terminal>): Promise<Terminal>;
-    update(id: number, data: Partial<Terminal>): Promise<Terminal>;
-    update(id: number, data: Partial<Terminal>, options: {
-        rawResponse: true;
-    } & Options): Promise<AxiosResponse<Terminal, any>>;
-    update(id: number, data: Partial<Terminal>, options: Options): Promise<Terminal>;
-    closeTerminal(id: number): Promise<number>;
-    closeTerminal(id: number, options: {
-        rawResponse: true;
-    } & Options): Promise<AxiosResponse<void>>;
-    closeTerminal(id: number, options: Options): Promise<number>;
-    list(): AsyncGenerator<Terminal>;
-    list<F extends keyof Terminal>(options: {
-        fields: F[];
-    } & OptionsExtended<Terminal>): AsyncGenerator<Pick<Terminal, F>>;
-    list(options?: OptionsExtended<Terminal>): AsyncGenerator<Terminal>;
-    listAll(): Promise<Terminal[]>;
-    listAll<F extends keyof Terminal>(options: {
-        fields: F[];
-    } & OptionsExtended<Terminal>): Promise<Pick<Terminal, F>[]>;
-    listAll(options?: OptionsExtended<Terminal>): Promise<Terminal[]>;
-    listByPage(): AsyncGenerator<AxiosResponse<Terminal[]>>;
-    listByPage<F extends keyof Terminal>(options: {
-        fields: F[];
-    } & OptionsExtended<Terminal>): AsyncGenerator<AxiosResponse<Pick<Terminal, F>[]>>;
-    listByPage(options?: OptionsExtended<Terminal>): AsyncGenerator<AxiosResponse<Terminal[]>>;
-}
-export {};