OpenAPI generator

export type Message = string;

export type OrderEnum = 'ascending' | 'descending';

import {Comment} from './comment.model';
export type Comments = Comment[];

import {model, property} from '@loopback/repository';
import {CartShippingZone} from './cart-shipping-zone.model';
import {CartStoreInfo} from './cart-store-info.model';
import {CartWarehouse} from './cart-warehouse.model';

/**
 * The model class is generated from OpenAPI schema - Cart
 * Cart
 */
@model({name: 'Cart'})
export class Cart {
  constructor(data?: Partial<Cart>) {
    if (data != null && typeof data === 'object') {
      Object.assign(this, data);
    }
  }

  @property({name: 'additional_fields'})
  additional_fields?: {};

  @property({name: 'custom_fields'})
  custom_fields?: {};

  @property({name: 'db_prefix'})
  db_prefix?: string;

  @property({name: 'name'})
  name?: string;

  @property({name: 'shipping_zones'})
  shipping_zones?: CartShippingZone[];

  @property({name: 'stores_info'})
  stores_info?: CartStoreInfo[];

  @property({name: 'url'})
  url?: string;

  @property({name: 'version'})
  version?: string;

  @property({name: 'warehouses'})
  warehouses?: CartWarehouse[];
}

export type IdType = string | number;

import {NewPet} from './new-pet.model.ts';
export type Pet = NewPet & {id: number};

@operation('post', '/{dataset}/{version}/records')
  async performSearch(
    @requestBody()
    body: {
      criteria: string;
      start?: number;
      rows?: number;
    },
    @param({name: 'version', in: 'path'}) version: string,
    @param({name: 'dataset', in: 'path'}) dataset: string,
  ): Promise<
    {
      [additionalProperty: string]: {};
    }[]
  > {
    throw new Error('Not implemented');
  }

/* eslint-disable @typescript-eslint/no-explicit-any */
import {model, property} from '@loopback/repository';

/**
 * The model class is generated from OpenAPI schema - performSearchBody
 * performSearchBody
 */
@model({name: 'performSearchBody'})
export class PerformSearchBody {
  constructor(data?: Partial<PerformSearchBody>) {
    if (data != null && typeof data === 'object') {
      Object.assign(this, data);
    }
  }

  /**
   * Uses Lucene Query Syntax in the format of propertyName:value, propertyName:[num1 TO num2] and date range format: propertyName:[yyyyMMdd TO yyyyMMdd]. In the response please see the 'docs' element which has the list of record objects. Each record structure would consist of all the fields and their corresponding values.
   */
  @property({name: 'criteria'})
  criteria: string = '*:*';

  /**
   * Starting record number. Default value is 0.
   */
  @property({name: 'start'})
  start?: number = 0;

  /**
   * Specify number of rows to be returned. If you run the search with default values, in the response you will see 'numFound' attribute which will tell the number of records available in the dataset.
   */
  @property({name: 'rows'})
  rows?: number = 100;
}

export type PerformSearchResponseBody = {
  [additionalProperty: string]: {};
}[];

import {operation, param} from '@loopback/rest';
import {DateTime} from '../models/date-time.model';

/**
 * The controller class is generated from OpenAPI spec with operations tagged
 * by account
 *
 */
export class AccountController {
  constructor() {}

  /**
   * Get list of carts.
   */
  @operation('get', '/account.cart.list.json')
  async accountCartList(
    @param({name: 'params', in: 'query'}) params: string,
    @param({name: 'exclude', in: 'query'}) exclude: string,
    @param({name: 'request_from_date', in: 'query'}) request_from_date: string,
    @param({name: 'request_to_date', in: 'query'}) request_to_date: string,
  ): Promise<{
    result?: {
      carts?: {
        cart_id?: string;
        id?: string;
        store_key?: string;
        total_calls?: string;
        url?: string;
      }[];
      carts_count?: number;
    };
    return_code?: number;
    return_message?: string;
  }> {
    throw new Error('Not implemented');
  }

  /**
   * Update configs in the API2Cart database.
   */
  @operation('put', '/account.config.update.json')
  async accountConfigUpdate(
    @param({name: 'db_tables_prefix', in: 'query'}) db_tables_prefix: string,
    @param({name: 'client_id', in: 'query'}) client_id: string,
    @param({name: 'bridge_url', in: 'query'}) bridge_url: string,
    @param({name: 'store_root', in: 'query'}) store_root: string,
    @param({name: 'shared_secret', in: 'query'}) shared_secret: string,
  ): Promise<{
    result?: {
      updated_items?: number;
    };
    return_code?: number;
    return_message?: string;
  }> {
    throw new Error('Not implemented');
  }

  /**
   * List webhooks that was not delivered to the callback.
   */
  @operation('get', '/account.failed_webhooks.json')
  async accountFailedWebhooks(
    @param({name: 'count', in: 'query'}) count: number,
    @param({name: 'start', in: 'query'}) start: number,
    @param({name: 'ids', in: 'query'}) ids: string,
  ): Promise<{
    result?: {
      all_failed_webhook?: string;
      webhook?: {
        entity_id?: string;
        time?: DateTime;
        webhook_id?: number;
      }[];
    };
    return_code?: number;
    return_message?: string;
  }> {
    throw new Error('Not implemented');
  }
}

import {inject, lifeCycleObserver, LifeCycleObserver} from '@loopback/core';
import {juggler} from '@loopback/repository';

const config = {
  name: 'test2',
  connector: 'openapi',
  spec: 'customer.yaml',
  validate: false,
  positional: true,
};

// Observe application's life cycle to disconnect the datasource when
// application is stopped. This allows the application to be shut down
// gracefully. The `stop()` method is inherited from `juggler.DataSource`.
// Learn more at https://loopback.io/doc/en/lb4/Life-cycle.html
@lifeCycleObserver('datasource')
export class Test2DataSource
  extends juggler.DataSource
  implements LifeCycleObserver
{
  static dataSourceName = 'test2';
  static readonly defaultConfig = config;

  constructor(
    @inject('datasources.config.test2', {optional: true})
    dsConfig: object = config,
  ) {
    super(dsConfig);
  }
}

import {getService} from '@loopback/service-proxy';
import {inject, Provider} from '@loopback/core';
import {Test2DataSource} from '../datasources';

import {Customer} from '../models/customer.model';

/**
 * The service interface is generated from OpenAPI spec with operations tagged
 * by Customer
 * Customer resource
 */
export interface CustomerService {
  /**
   * Returns all customers (\/* customers *\/)
   *
   * @param _if if condition
   * @param limit maximum number of results to return
   * @param accessToken Access token (\/* access_token *\/)
   * @returns customer response
   */
  getCustomers(
    _if: string[],
    limit: number,
    accessToken: string,
  ): Promise<Customer[]>;

  /**
   * Creates a new customer
   *
   * @param _requestBody Customer to add
   * @param accessToken Access token (\/* access_token *\/)
   * @returns customer response
   */
  createCustomer(
    _requestBody: Customer,
    accessToken: string,
  ): Promise<Customer>;

  // If `--no-positional` is supplied, we generate an object as the params:
  /**
   * ```ts
   * createCustomer(params: {
   *   _requestBody: Customer;
   *   accessToken: string;
   * }): Promise<Customer>;
   * ```
   */

  /**
   * Returns a customer based on a single ID
   *
   * @param customerId ID of customer to fetch
   * @returns customer response
   */
  findCustomerById(customerId: number): Promise<Customer>;
}

export class CustomerServiceProvider implements Provider<CustomerService> {
  constructor(
    // test2 must match the name property in the datasource json file
    @inject('datasources.test2')
    protected dataSource: Test2DataSource = new Test2DataSource(),
  ) {}

  async value(): Promise<CustomerService> {
    const service = await getService<{apis: Record<string, CustomerService>}>(
      this.dataSource,
    );
    return service.apis['Customer'];
  }
}