rotacloud 1.5.2 → 2.0.0

package/src/services/roles.service.ts

@@ -1,96 +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 class RolesService extends Service<Role> {
-  private apiPath = '/roles';
-
-  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>;
-  create(data: RequirementsOf<Role, RequiredProps>, options?: Options) {
-    return super
-      .fetch<Role>({ url: this.apiPath, data, method: 'POST' }, options)
-      .then((res) => (options?.rawResponse ? res : res.data));
-  }
-
-  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>;
-  get(id: number, options?: OptionsExtended<Role>) {
-    return super
-      .fetch<Role>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => (options?.rawResponse ? res : res.data));
-  }
-
-  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>;
-  async *list(query?: RolesQueryParams, options?: OptionsExtended<Role>) {
-    yield* super.iterator({ url: this.apiPath, params: query }, options);
-  }
-
-  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[]>;
-  async listAll(query?: RolesQueryParams, options?: OptionsExtended<Role>) {
-    const roles = [] as Role[];
-    for await (const role of this.list(query, options)) {
-      roles.push(role);
-    }
-    return roles;
-  }
-
-  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[]>>;
-  listByPage(query?: RolesQueryParams, options?: OptionsExtended<Role>) {
-    return super.iterator({ url: this.apiPath, params: query }, options).byPage();
-  }
-
-  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>;
-  update(id: number, data: Partial<Role>, options?: Options) {
-    return super
-      .fetch<Role>(
-        {
-          url: `${this.apiPath}/${id}`,
-          data,
-          method: 'POST',
-        },
-        options,
-      )
-      .then((res) => (options?.rawResponse ? res : res.data));
-  }
-
-  delete(id: number): Promise<number>;
-  delete(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<void>>;
-  delete(id: number, options: Options): Promise<number>;
-  delete(id: number, options?: Options) {
-    return super
-      .fetch<void>({ url: `${this.apiPath}/${id}`, method: 'DELETE' }, options)
-      .then((res) => (options?.rawResponse ? res : res.status));
-  }
-}

package/src/services/service.ts

@@ -1,168 +0,0 @@
-import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
-import { Version } from '../version.js';
-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)[];
-};
-
-type ParameterPrimitive = string | boolean | number | null | symbol;
-type ParameterValue = ParameterPrimitive | ParameterPrimitive[] | undefined;
-
-export abstract class Service<ApiResponse = any> {
-  constructor(
-    protected client: AxiosInstance,
-    // 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
-    protected readonly options: { config: SDKConfig },
-  ) {}
-
-  private isLeaveRequest(endpoint?: string): boolean {
-    return endpoint === '/leave_requests';
-  }
-
-  private buildQueryParams<T = ApiResponse>(
-    options?: OptionsExtended<T>,
-    extraParams?: Record<string, ParameterValue>,
-  ) {
-    const queryParams: Record<string, ParameterValue> = {
-      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;
-    }, [] as string[][]);
-
-    return new URLSearchParams(reducedParams);
-  }
-
-  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>>>;
-  fetch<T = ApiResponse>(reqConfig: AxiosRequestConfig, options?: Options) {
-    const headers: Record<string, string> = {
-      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: AxiosRequestConfig<T> = {
-      ...reqConfig,
-      baseURL: this.options.config.baseUri,
-      headers,
-      params: this.buildQueryParams(options, reqConfig.params),
-    };
-
-    return this.client.request<T>(finalReqConfig);
-  }
-
-  /** Iterates through every page for a potentially paginated request */
-  private fetchPages<T = ApiResponse>(
-    reqConfig: AxiosRequestConfig<T[]>,
-    options: { fields: Required<OptionsExtended<T>>['fields'] } & OptionsExtended<T>,
-  ): AsyncGenerator<AxiosResponse<Pick<T, (typeof options)['fields'][number]>[]>>;
-  private fetchPages<T = ApiResponse>(
-    reqConfig: AxiosRequestConfig<T[]>,
-    options?: Options,
-  ): AsyncGenerator<AxiosResponse<T[]>>;
-  private async *fetchPages<T = ApiResponse>(
-    reqConfig: AxiosRequestConfig<T[]>,
-    options?: Options,
-  ): AsyncGenerator<AxiosResponse<T[]>> {
-    const fallbackLimit = 20;
-    const res = await this.fetch<T[]>(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<T[]>(reqConfig, { ...options, offset });
-    }
-  }
-
-  private async *listResponses<T = ApiResponse>(reqConfig: AxiosRequestConfig<T[]>, options?: Options) {
-    if (!options?.maxResults) {
-      for await (const res of this.fetchPages<T>(reqConfig, options)) {
-        yield* res.data;
-      }
-      return;
-    }
-
-    let entityCount = 0;
-    for await (const res of this.fetchPages<T>(reqConfig, options)) {
-      for (const entity of res.data) {
-        yield entity;
-        entityCount += 1;
-        if (entityCount >= options.maxResults) return;
-      }
-    }
-  }
-
-  iterator<T = ApiResponse>(reqConfig: AxiosRequestConfig<T[]>, options?: Options) {
-    return {
-      [Symbol.asyncIterator]: () => this.listResponses<T>(reqConfig, options),
-      byPage: () => this.fetchPages<T>(reqConfig, options),
-    };
-  }
-}

package/src/services/settings.service.ts

@@ -1,19 +0,0 @@
-import { AxiosResponse } from 'axios';
-import { Service, Options } from './index.js';
-
-import { Settings } from '../interfaces/index.js';
-
-import { SettingsQueryParams } from '../rotacloud.js';
-
-export class SettingsService extends Service<Settings> {
-  private apiPath = '/settings';
-
-  get(query: SettingsQueryParams): Promise<Settings>;
-  get(query: SettingsQueryParams, options: { rawResponse: true } & Options): Promise<AxiosResponse<Settings, any>>;
-  get(query: SettingsQueryParams, options: Options): Promise<Settings>;
-  get(query: SettingsQueryParams, options?: Options) {
-    return super
-      .fetch<Settings>({ url: `${this.apiPath}`, params: query }, options)
-      .then((res) => (options?.rawResponse ? res : res.data));
-  }
-}

package/src/services/shifts.service.ts

@@ -1,200 +0,0 @@
-import { AxiosRequestConfig, 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 class ShiftsService extends Service<Shift> {
-  private apiPath = '/shifts';
-
-  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>;
-  create(data: RequirementsOf<Shift, RequiredProps>, options?: Options) {
-    return super
-      .fetch<Shift>({ url: this.apiPath, data, method: 'POST' }, options)
-      .then((res) => (options?.rawResponse ? res : res.data));
-  }
-
-  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>;
-  get(id: number, options?: OptionsExtended<Shift>) {
-    return super
-      .fetch<Shift>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => (options?.rawResponse ? res : res.data));
-  }
-
-  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>;
-  async *list(query: ShiftsQueryParams, options?: OptionsExtended<Shift>) {
-    yield* super.iterator({ url: this.apiPath, params: query }, options);
-  }
-
-  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[]>;
-  async listAll(query: ShiftsQueryParams, options?: OptionsExtended<Shift>) {
-    const shifts = [] as Shift[];
-    for await (const shift of this.list(query, options)) {
-      shifts.push(shift);
-    }
-    return shifts;
-  }
-
-  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[]>>;
-  listByPage(query: ShiftsQueryParams, options?: OptionsExtended<Shift>) {
-    return super.iterator<Shift>({ url: this.apiPath, params: query }, options).byPage();
-  }
-
-  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 }[] }>;
-  update(shifts: RequirementsOf<Shift, 'id'> | RequirementsOf<Shift, 'id'>[], options?: Options) {
-    if (!Array.isArray(shifts)) {
-      return super
-        .fetch<Shift>(
-          {
-            url: `${this.apiPath}/${shifts.id}`,
-            data: shifts,
-            method: 'POST',
-          },
-          options,
-        )
-        .then((res) => (options?.rawResponse ? res : res.data));
-    }
-
-    return super
-      .fetch<{ code: number; data?: Shift; error?: string }[]>(
-        {
-          url: this.apiPath,
-          data: shifts,
-          method: 'POST',
-        },
-        options,
-      )
-      .then((res) => {
-        if (options?.rawResponse) return res;
-
-        const success: Shift[] = [];
-        const failed: { id: number; error: string }[] = [];
-        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: number | number[]): Promise<number>;
-  delete(ids: number | number[], options: { rawResponse: true } & Options): Promise<AxiosResponse<void>>;
-  delete(ids: number | number[], options: Options): Promise<number>;
-  delete(ids: number | number[], options?: Options) {
-    const params: AxiosRequestConfig = Array.isArray(ids)
-      ? { url: this.apiPath, data: { ids }, method: 'DELETE' }
-      : { url: `${this.apiPath}/${ids}`, method: 'DELETE' };
-
-    return super.fetch<void>(params, options).then((res) => (options?.rawResponse ? res : res.status));
-  }
-
-  acknowledge(shifts: number[]): Promise<number>;
-  acknowledge(shifts: number[], options: { rawResponse: true } & Options): Promise<AxiosResponse<any>>;
-  acknowledge(shifts: number[], options: Options): Promise<number>;
-  acknowledge(shifts: number[], options?: Options) {
-    return super
-      .fetch<Shift>({ url: '/shifts_acknowledged', data: { shifts }, method: 'POST' }, options)
-      .then((res) => (options?.rawResponse ? res : res.status));
-  }
-
-  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>;
-  publish(data: { shifts: number[] }, options?: Options) {
-    return super
-      .fetch<Shift>({ url: '/shifts_published', data, method: 'POST' }, options)
-      .then((res) => (options?.rawResponse ? res : res.status));
-  }
-
-  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>;
-  unpublish(data: { shifts: number[] }, options?: Options) {
-    return super
-      .fetch<Shift>({ url: '/shifts_published', data, method: 'DELETE' }, options)
-      .then((res) => (options?.rawResponse ? res : res.status));
-  }
-
-  updateSwap(data: ShiftSwapRequest): Promise<ShiftSwapRequest>;
-  updateSwap(
-    data: ShiftSwapRequest,
-    options: { rawResponse: true } & Options,
-  ): Promise<AxiosResponse<ShiftSwapRequest>>;
-  updateSwap(data: ShiftSwapRequest, options: Options): Promise<ShiftSwapRequest>;
-  updateSwap(data: ShiftSwapRequest, options?: Options) {
-    return super
-      .fetch<Shift>({ url: `/swap_requests/${data.id}`, data, method: 'POST' }, options)
-      .then((res) => (options?.rawResponse ? res : res.data));
-  }
-
-  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>;
-  updateDrop(
-    data: { request: RequirementsOf<ShiftDropRequest, 'id' | 'user_message'>; approved: boolean },
-    options?: Options,
-  ) {
-    return super
-      .fetch<Shift>(
-        {
-          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/src/services/terminals-active.service.ts

@@ -1,85 +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 class TerminalsActiveService extends Service<Terminal> {
-  private apiPath = '/terminals_active';
-
-  launchTerminal(data: LaunchTerminal): Promise<Terminal>;
-  launchTerminal(data: LaunchTerminal, options: { rawResponse: true } & Options): Promise<AxiosResponse<Terminal>>;
-  launchTerminal(data: LaunchTerminal, options: Options): Promise<Terminal>;
-  launchTerminal(data: LaunchTerminal, options?: Options) {
-    return super
-      .fetch<Terminal>(
-        {
-          url: this.apiPath,
-          data,
-          method: 'POST',
-        },
-        options,
-      )
-      .then((res) => (options?.rawResponse ? res : res.data));
-  }
-
-  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>;
-  pingTerminal(id: number, data: PingTerminal, options?: Options) {
-    return super
-      .fetch<number>({ url: `${this.apiPath}/${id}`, data, method: 'POST' }, options)
-      .then((res) => (options?.rawResponse ? res : res.data));
-  }
-
-  list(): AsyncGenerator<Terminal>;
-  list<F extends keyof Terminal>(
-    options: { fields: F[] } & OptionsExtended<Terminal>,
-  ): AsyncGenerator<Pick<Terminal, F>>;
-  list(options?: OptionsExtended<Terminal>): AsyncGenerator<Terminal>;
-  async *list(options?: OptionsExtended<Terminal>) {
-    yield* super.iterator({ url: this.apiPath }, options);
-  }
-
-  listAll(): Promise<Terminal[]>;
-  listAll<F extends keyof Terminal>(options: { fields: F[] } & OptionsExtended<Terminal>): Promise<Pick<Terminal, F>[]>;
-  listAll(options?: OptionsExtended<Terminal>): Promise<Terminal[]>;
-  async listAll(options?: OptionsExtended<Terminal>) {
-    const users = [] as Terminal[];
-    for await (const user of this.list(options)) {
-      users.push(user);
-    }
-    return users;
-  }
-
-  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[]>>;
-  listByPage(options?: OptionsExtended<Terminal>) {
-    return super.iterator({ url: this.apiPath }, options).byPage();
-  }
-
-  closeTerminal(id: number): Promise<number>;
-  closeTerminal(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<void>>;
-  closeTerminal(id: number, options: Options): Promise<number>;
-  closeTerminal(id: number, options?: Options) {
-    return super
-      .fetch<void>({ url: `${this.apiPath}/${id}`, method: 'DELETE' }, options)
-      .then((res) => (options?.rawResponse ? res : res.status));
-  }
-}

package/src/services/terminals.service.ts

@@ -1,93 +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 class TerminalsService extends Service<Terminal> {
-  private apiPath = '/terminals';
-
-  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>;
-  create(data: RequirementsOf<Terminal, RequiredProps>, options?: Options) {
-    return super
-      .fetch<Terminal>({ url: this.apiPath, data, method: 'POST' })
-      .then((res) => (options?.rawResponse ? res : res.data));
-  }
-
-  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>;
-  get(id: number, options?: Options) {
-    return super
-      .fetch<Terminal>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => (options?.rawResponse ? res : res.data));
-  }
-
-  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>;
-  update(id: number, data: Partial<Terminal>, options?: Options) {
-    return super
-      .fetch<Terminal>({
-        url: `${this.apiPath}/${id}`,
-        data,
-        method: 'POST',
-      })
-      .then((res) => (options?.rawResponse ? res : res.data));
-  }
-
-  closeTerminal(id: number): Promise<number>;
-  closeTerminal(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<void>>;
-  closeTerminal(id: number, options: Options): Promise<number>;
-  closeTerminal(id: number, options?: Options) {
-    return super
-      .fetch<void>({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
-      .then((res) => (options?.rawResponse ? res : res.status));
-  }
-
-  list(): AsyncGenerator<Terminal>;
-  list<F extends keyof Terminal>(
-    options: { fields: F[] } & OptionsExtended<Terminal>,
-  ): AsyncGenerator<Pick<Terminal, F>>;
-  list(options?: OptionsExtended<Terminal>): AsyncGenerator<Terminal>;
-  async *list(options?: OptionsExtended<Terminal>) {
-    yield* super.iterator({ url: this.apiPath }, options);
-  }
-
-  listAll(): Promise<Terminal[]>;
-  listAll<F extends keyof Terminal>(options: { fields: F[] } & OptionsExtended<Terminal>): Promise<Pick<Terminal, F>[]>;
-  listAll(options?: OptionsExtended<Terminal>): Promise<Terminal[]>;
-  async listAll(options?: OptionsExtended<Terminal>) {
-    const users = [] as Terminal[];
-    for await (const user of this.list(options)) {
-      users.push(user);
-    }
-    return users;
-  }
-
-  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[]>>;
-  listByPage(options?: OptionsExtended<Terminal>) {
-    return super.iterator({ url: this.apiPath }, options).byPage();
-  }
-}