@nextplus/js-sdk 0.0.4 → 0.0.6

package/dist/types.gen-vDP9AbtO.d.cts

@@ -0,0 +1,258 @@
+type AuthToken = string | undefined;
+interface Auth {
+    /**
+     * Which part of the request do we use to send the auth?
+     *
+     * @default 'header'
+     */
+    in?: 'header' | 'query' | 'cookie';
+    /**
+     * Header or query parameter name.
+     *
+     * @default 'Authorization'
+     */
+    name?: string;
+    scheme?: 'basic' | 'bearer';
+    type: 'apiKey' | 'http';
+}
+
+interface SerializerOptions<T> {
+    /**
+     * @default true
+     */
+    explode: boolean;
+    style: T;
+}
+type ArrayStyle = 'form' | 'spaceDelimited' | 'pipeDelimited';
+type ObjectStyle = 'form' | 'deepObject';
+
+type QuerySerializer = (query: Record<string, unknown>) => string;
+type BodySerializer = (body: any) => any;
+interface QuerySerializerOptions {
+    allowReserved?: boolean;
+    array?: SerializerOptions<ArrayStyle>;
+    object?: SerializerOptions<ObjectStyle>;
+}
+declare const formDataBodySerializer: {
+    bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(body: T) => FormData;
+};
+declare const jsonBodySerializer: {
+    bodySerializer: <T>(body: T) => string;
+};
+declare const urlSearchParamsBodySerializer: {
+    bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(body: T) => string;
+};
+
+interface Client$1<RequestFn = never, Config = unknown, MethodFn = never, BuildUrlFn = never> {
+    /**
+     * Returns the final request URL.
+     */
+    buildUrl: BuildUrlFn;
+    connect: MethodFn;
+    delete: MethodFn;
+    get: MethodFn;
+    getConfig: () => Config;
+    head: MethodFn;
+    options: MethodFn;
+    patch: MethodFn;
+    post: MethodFn;
+    put: MethodFn;
+    request: RequestFn;
+    setConfig: (config: Config) => Config;
+    trace: MethodFn;
+}
+interface Config$1 {
+    /**
+     * Auth token or a function returning auth token. The resolved value will be
+     * added to the request payload as defined by its `security` array.
+     */
+    auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
+    /**
+     * A function for serializing request body parameter. By default,
+     * {@link JSON.stringify()} will be used.
+     */
+    bodySerializer?: BodySerializer | null;
+    /**
+     * An object containing any HTTP headers that you want to pre-populate your
+     * `Headers` object with.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
+     */
+    headers?: RequestInit['headers'] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined | unknown>;
+    /**
+     * The request method.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
+     */
+    method?: 'CONNECT' | 'DELETE' | 'GET' | 'HEAD' | 'OPTIONS' | 'PATCH' | 'POST' | 'PUT' | 'TRACE';
+    /**
+     * A function for serializing request query parameters. By default, arrays
+     * will be exploded in form style, objects will be exploded in deepObject
+     * style, and reserved characters are percent-encoded.
+     *
+     * This method will have no effect if the native `paramsSerializer()` Axios
+     * API function is used.
+     *
+     * {@link https://swagger.io/docs/specification/serialization/#query View examples}
+     */
+    querySerializer?: QuerySerializer | QuerySerializerOptions;
+    /**
+     * A function validating request data. This is useful if you want to ensure
+     * the request conforms to the desired shape, so it can be safely sent to
+     * the server.
+     */
+    requestValidator?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function transforming response data before it's returned. This is useful
+     * for post-processing data, e.g. converting ISO strings into Date objects.
+     */
+    responseTransformer?: (data: unknown) => Promise<unknown>;
+    /**
+     * A function validating response data. This is useful if you want to ensure
+     * the response conforms to the desired shape, so it can be safely passed to
+     * the transformers and returned to the user.
+     */
+    responseValidator?: (data: unknown) => Promise<unknown>;
+}
+
+declare const mergeHeaders: (...headers: Array<Required<Config>["headers"] | undefined>) => Headers;
+type ErrInterceptor<Err, Res, Req, Options> = (error: Err, response: Res, request: Req, options: Options) => Err | Promise<Err>;
+type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
+type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
+declare class Interceptors<Interceptor> {
+    _fns: (Interceptor | null)[];
+    constructor();
+    clear(): void;
+    getInterceptorIndex(id: number | Interceptor): number;
+    exists(id: number | Interceptor): boolean;
+    eject(id: number | Interceptor): void;
+    update(id: number | Interceptor, fn: Interceptor): number | false | Interceptor;
+    use(fn: Interceptor): number;
+}
+interface Middleware<Req, Res, Err, Options> {
+    error: Pick<Interceptors<ErrInterceptor<Err, Res, Req, Options>>, 'eject' | 'use'>;
+    request: Pick<Interceptors<ReqInterceptor<Req, Options>>, 'eject' | 'use'>;
+    response: Pick<Interceptors<ResInterceptor<Res, Req, Options>>, 'eject' | 'use'>;
+}
+declare const createConfig: <T extends ClientOptions = ClientOptions>(override?: Config<Omit<ClientOptions, keyof T> & T>) => Config<Omit<ClientOptions, keyof T> & T>;
+
+type ResponseStyle = 'data' | 'fields';
+interface Config<T extends ClientOptions = ClientOptions> extends Omit<RequestInit, 'body' | 'headers' | 'method'>, Config$1 {
+    /**
+     * Base URL for all requests made by this client.
+     */
+    baseUrl?: T['baseUrl'];
+    /**
+     * Fetch API implementation. You can use this option to provide a custom
+     * fetch instance.
+     *
+     * @default globalThis.fetch
+     */
+    fetch?: (request: Request) => ReturnType<typeof fetch>;
+    /**
+     * Please don't use the Fetch client for Next.js applications. The `next`
+     * options won't have any effect.
+     *
+     * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
+     */
+    next?: never;
+    /**
+     * Return the response data parsed in a specified format. By default, `auto`
+     * will infer the appropriate method from the `Content-Type` response header.
+     * You can override this behavior with any of the {@link Body} methods.
+     * Select `stream` if you don't want to parse response data at all.
+     *
+     * @default 'auto'
+     */
+    parseAs?: 'arrayBuffer' | 'auto' | 'blob' | 'formData' | 'json' | 'stream' | 'text';
+    /**
+     * Should we return only data or multiple fields (data, error, response, etc.)?
+     *
+     * @default 'fields'
+     */
+    responseStyle?: ResponseStyle;
+    /**
+     * Throw an error instead of returning it in the response?
+     *
+     * @default false
+     */
+    throwOnError?: T['throwOnError'];
+}
+interface RequestOptions<TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends Config<{
+    responseStyle: TResponseStyle;
+    throwOnError: ThrowOnError;
+}> {
+    /**
+     * Any body that you want to add to your request.
+     *
+     * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
+     */
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    /**
+     * Security mechanism(s) to use for the request.
+     */
+    security?: ReadonlyArray<Auth>;
+    url: Url;
+}
+interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<TResponseStyle, ThrowOnError, Url> {
+    serializedBody?: string;
+}
+type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = 'fields'> = ThrowOnError extends true ? Promise<TResponseStyle extends 'data' ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    request: Request;
+    response: Response;
+}> : Promise<TResponseStyle extends 'data' ? (TData extends Record<string, unknown> ? TData[keyof TData] : TData) | undefined : ({
+    data: TData extends Record<string, unknown> ? TData[keyof TData] : TData;
+    error: undefined;
+} | {
+    data: undefined;
+    error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
+}) & {
+    request: Request;
+    response: Response;
+}>;
+interface ClientOptions {
+    baseUrl?: string;
+    responseStyle?: ResponseStyle;
+    throwOnError?: boolean;
+}
+type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TResponseStyle, ThrowOnError>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions<TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+type BuildUrlFn = <TData extends {
+    body?: unknown;
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    url: string;
+}>(options: Pick<TData, 'url'> & Options<TData>) => string;
+type Client = Client$1<RequestFn, Config, MethodFn, BuildUrlFn> & {
+    interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
+};
+/**
+ * The `createClientConfig()` function will be called on client initialization
+ * and the returned object will become the client's initial configuration.
+ *
+ * You may want to initialize your client this way instead of calling
+ * `setConfig()`. This is useful for example if you're using Next.js
+ * to ensure your client always has the correct values.
+ */
+type CreateClientConfig<T extends ClientOptions = ClientOptions> = (override?: Config<ClientOptions & T>) => Config<Required<ClientOptions> & T>;
+interface TDataShape {
+    body?: unknown;
+    headers?: unknown;
+    path?: unknown;
+    query?: unknown;
+    url: string;
+}
+type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
+type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = 'fields'> = OmitKeys<RequestOptions<TResponseStyle, ThrowOnError>, 'body' | 'path' | 'query' | 'url'> & Omit<TData, 'url'>;
+type OptionsLegacyParser<TData = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = 'fields'> = TData extends {
+    body?: any;
+} ? TData extends {
+    headers?: any;
+} ? OmitKeys<RequestOptions<TResponseStyle, ThrowOnError>, 'body' | 'headers' | 'url'> & TData : OmitKeys<RequestOptions<TResponseStyle, ThrowOnError>, 'body' | 'url'> & TData & Pick<RequestOptions<TResponseStyle, ThrowOnError>, 'headers'> : TData extends {
+    headers?: any;
+} ? OmitKeys<RequestOptions<TResponseStyle, ThrowOnError>, 'headers' | 'url'> & TData & Pick<RequestOptions<TResponseStyle, ThrowOnError>, 'body'> : OmitKeys<RequestOptions<TResponseStyle, ThrowOnError>, 'url'> & TData;
+
+export { type Auth as A, type Client as C, type Options as O, type QuerySerializerOptions as Q, type RequestResult as R, type TDataShape as T, type Config as a, type ClientOptions as b, type CreateClientConfig as c, type OptionsLegacyParser as d, type RequestOptions as e, formDataBodySerializer as f, type ResolvedRequestOptions as g, type ResponseStyle as h, createConfig as i, jsonBodySerializer as j, mergeHeaders as m, urlSearchParamsBodySerializer as u };

package/package.json

@@ -1,20 +1,37 @@
 {
   "name": "@nextplus/js-sdk",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "type": "module",
   "scripts": {
     "generate": "npm run clean && npm run openapi-ts && npm run build",
-    "build": "tsup src/index.ts src/sdk/client/index.ts src/sdk/sdk.gen.ts src/smoke.ts --dts --format esm --outDir dist --clean",
+    "build": "tsup src/index.ts src/sdk/index.ts src/sdk/client/index.ts src/sdk/sdk.gen.ts src/smoke.ts --dts --format esm,cjs --outDir dist --clean",
     "clean": "rm -rf dist",
-    "prepublishOnly": "npm run clean && tsup src/index.ts src/sdk/client/index.ts src/sdk/sdk.gen.ts --dts --format esm --outDir dist --clean",
+    "prepublishOnly": "npm run clean && tsup src/index.ts src/sdk/index.ts src/sdk/client/index.ts src/sdk/sdk.gen.ts --dts --format esm,cjs --outDir dist --clean",
     "lint": "eslint . --ext ts,tsx --report-unused-disable-directives --max-warnings 0",
     "openapi-ts": "openapi-ts",
     "test": "npm run build && node dist/smoke.js"
   },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "require": "./dist/index.cjs"
+    },
+    "./sdk": {
+      "types": "./dist/sdk/index.d.ts",
+      "import": "./dist/sdk/index.js",
+      "require": "./dist/sdk/index.cjs"
+    },
+    "./sdk/client": {
+      "types": "./dist/sdk/client/index.d.ts",
+      "import": "./dist/sdk/client/index.js",
+      "require": "./dist/sdk/client/index.cjs"
     }
   },
   "main": "dist/index.js",

package/src/index.ts

@@ -2,6 +2,7 @@ import debug from 'debug';
 import { createClient } from './sdk/client';
 import { UserModelService } from './sdk';
 import * as AllServices from './sdk';
+import type * as AllServiceTypes from './sdk';
 
 const log = debug('nextplus:sdk');
 
@@ -35,11 +36,88 @@ const isTokenValid = (): boolean => {
 
 
 
-class NextPlusSDK {
+export class NextPlusSDK {
   private client: any;
   private credentials: { email?: string; username?: string; password: string };
   private returnType: 'raw' | 'data' = 'data';
 
+  // Wrap plain developer inputs into the right container (body/query)
+  // and stringify complex query params when required by LoopBack (filter/where)
+  private normalizeOptions(methodName: string, rawOptions: any): any {
+    const options: any = rawOptions && typeof rawOptions === 'object' ? { ...rawOptions } : {};
+
+    // Always ensure client is set (will be set by caller afterwards if missing)
+    // We avoid mutating the original object to keep predictable behavior
+
+    // If developer passed top-level filter/where/fields/order/limit/offset/include
+    // without wrapping into query, move them into a filter object for find/findOne
+    const method = methodName.toString().toLowerCase();
+    const isFind = method.includes('find') && !method.includes('count');
+    const isCount = method.includes('count');
+    const shouldUseBody = /(create|update|replace|patch|login|upsert)/i.test(methodName.toString());
+
+    const topLevelKeys = ['filter', 'where', 'fields', 'order', 'limit', 'offset', 'include'];
+    const hasTopLevelFilterBits = topLevelKeys.some((k) => Object.prototype.hasOwnProperty.call(options, k));
+
+    // Only create query if relevant for this method
+    if (isFind) {
+      options.query = options.query || {};
+      // If developer provided a full filter at top-level as object, stringify it
+      if (options.filter && typeof options.filter === 'object') {
+        options.query.filter = JSON.stringify(options.filter);
+        delete options.filter;
+      } else if (hasTopLevelFilterBits) {
+        const filterObject: any = {};
+        if (options.where !== undefined) filterObject.where = options.where;
+        if (options.fields !== undefined) filterObject.fields = options.fields;
+        if (options.order !== undefined) filterObject.order = options.order;
+        if (options.limit !== undefined) filterObject.limit = options.limit;
+        if (options.offset !== undefined) filterObject.offset = options.offset;
+        if (options.include !== undefined) filterObject.include = options.include;
+        if (Object.keys(filterObject).length > 0) {
+          options.query.filter = typeof filterObject === 'string' ? filterObject : JSON.stringify(filterObject);
+        }
+        // Clean moved keys from top-level
+        topLevelKeys.forEach((k) => delete options[k]);
+      }
+    } else if (isCount) {
+      options.query = options.query || {};
+      // Allow top-level where or query.where as object → stringify
+      if (options.where !== undefined) {
+        const whereVal = options.where;
+        options.query.where = typeof whereVal === 'string' ? whereVal : JSON.stringify(whereVal);
+        delete options.where;
+      }
+    } else if (shouldUseBody) {
+      // For create/update-like methods: allow passing the payload at top-level → move to body
+      if (options.body === undefined) {
+        const bodyCandidate: any = { ...options };
+        delete bodyCandidate.client;
+        delete bodyCandidate.query;
+        delete bodyCandidate.path;
+        if (Object.keys(bodyCandidate).length > 0) {
+          options.body = bodyCandidate;
+          // Keep only body/client/query/path at root
+          Object.keys(options).forEach((k) => {
+            if (!['body', 'client', 'query', 'path'].includes(k)) delete options[k];
+          });
+        }
+      }
+    }
+
+    // If developer already provided query, stringify any object/array values automatically
+    if (options.query && typeof options.query === 'object') {
+      Object.keys(options.query).forEach((key) => {
+        const val = options.query[key];
+        if (val && (Array.isArray(val) || typeof val === 'object')) {
+          options.query[key] = JSON.stringify(val);
+        }
+      });
+    }
+
+    return options;
+  }
+
   constructor(options: {
     baseURL: string;
     email?: string;
@@ -160,11 +238,10 @@ class NextPlusSDK {
         if (typeof target[prop] === 'function') {
           return async function(...args: any[]) {
             // Automatically inject client if not provided
-            if (args[0] && typeof args[0] === 'object' && !args[0].client) {
-              args[0].client = self.client;
-            } else if (!args[0]) {
-              args[0] = { client: self.client };
-            }
+            if (!args[0]) args[0] = {};
+            // Normalize developer-friendly input into OpenAPI options
+            args[0] = self.normalizeOptions(String(prop), args[0]);
+            if (!args[0].client) args[0].client = self.client;
 
             const result = await target[prop].apply(target, args);
 
@@ -194,15 +271,24 @@ class NextPlusSDK {
   }
 }
 
+// Expose accurate static service method types on the SDK instance for IDE/type safety
+type ServiceStatics = {
+  [K in keyof typeof AllServiceTypes as K extends `${string}Service` ? K : never]: typeof AllServiceTypes[K];
+};
+
+export interface NextPlusSDK extends ServiceStatics {}
+
 // Legacy function for backward compatibility
+type SDKInstance = NextPlusSDK & ServiceStatics;
+
 const configure = (options: {
   baseURL: string;
   email?: string;
   username?: string;
   password: string;
   returnType?: 'raw' | 'data';
-}) => {
-  return new NextPlusSDK(options);
+}): SDKInstance => {
+  return new NextPlusSDK(options) as SDKInstance;
 };
 
 // Create SDK instance
@@ -212,8 +298,9 @@ const createSDK = (options: {
   username?: string;
   password: string;
   returnType?: 'raw' | 'data';
-}) => {
-  return new NextPlusSDK(options);
+}): SDKInstance => {
+  return new NextPlusSDK(options) as SDKInstance;
 };
 
-export { configure, createSDK, NextPlusSDK };
+export type { SDKInstance };
+export { configure, createSDK };

package/src/sdk/types.gen.ts

@@ -32619,6 +32619,7 @@ export type TableGetTableCountData = {
   };
   query?: {
     where?: string;
+    deleted?: boolean;
   };
   url: '/Tables/getTableCount/{tableId}';
 };

package/src/smoke.ts

@@ -12,12 +12,22 @@ async function main() {
   console.log('SDK configured (email)');
 
   // Test with returnType: 'data' - should return only the data array
-  const tables = await (sdk as any).TableService.find({
-    filter: {
-      name: {
-        eq: 'test',
-      },
-    },
+  const tables = await sdk.TableService.find({
+    query: {
+      filter: JSON.stringify({
+        language: 'he',
+        limit: 10,
+        order: 'created DESC',
+        fields: {
+          id: true,
+          name: true,
+          created: true
+        },
+        where: {
+          name: 'no-such-table!'
+        }
+      })
+    }
   });
 
   console.log(
@@ -26,9 +36,7 @@ async function main() {
   );
   // Test validation error handling
   try {
-    const newTable = await (sdk as any).TableService.create({
-      body: {},
-    });
+    const newTable = await sdk.TableService.create({ body: {} } as any);
     console.log('New table created:', newTable);
   } catch (error: any) {
     console.log('Expected validation error caught:', error.message);
@@ -46,12 +54,15 @@ async function main() {
   console.log('SDK configured (username)');
 
   // Test with returnType: 'raw' - should return { data, request, response }
-  const tablesRaw = await (sdk2 as any).TableService.find({
-    filter: {
-      name: {
-        eq: 'test',
-      },
-    },
+  const tablesRaw = await sdk2.TableService.find({
+    query: {
+      filter: JSON.stringify({
+        where: {
+          name: 'test'
+        },
+        limit: 5
+      })
+    }
   });
 
   console.log('Tables found (raw response):', {
@@ -62,9 +73,7 @@ async function main() {
   });
 
   try {
-    const createTable = await (sdk2 as any).TableService.create({
-      body: {},
-    });
+    const createTable = await sdk2.TableService.create({ body: {} } as any);
     console.log('Table created:', createTable);
   } catch (error: any) {
     console.log('Expected validation error caught (raw mode):', error.message);

package/openapi-ts.config.ts

@@ -1,36 +0,0 @@
-import { defineConfig } from '@hey-api/openapi-ts';
-
-export default defineConfig({
-  input: 'http://127.0.0.1:3000/explorer/swagger.json',
-  output: {
-    format: 'prettier',
-    lint: 'eslint',
-    path: './src/sdk',
-  },
-  plugins: [
-    '@hey-api/schemas',
-    {
-      dates: true,
-      name: '@hey-api/transformers',
-    },
-    {
-      enums: 'javascript',
-      name: '@hey-api/typescript',
-    },
-    {
-      name: '@hey-api/sdk',
-      asClass: true,
-      transformer: true,
-      classNameBuilder(name) {
-        return `${name}Service`;
-      },
-      methodNameBuilder(operation) {
-        return String(operation.id);
-      },
-    },
-    {
-      enums: 'javascript',
-      name: '@hey-api/typescript',
-    },
-  ],
-});

package/prettier.config.js

@@ -1,5 +0,0 @@
-/** @type {import("prettier").Config} */
-export default {
-  semi: true,
-  singleQuote: true,
-};

package/tsconfig.json

@@ -1,23 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "useDefineForClassFields": true,
-    "lib": ["ES2020", "DOM", "DOM.Iterable"],
-    "module": "ESNext",
-    "skipLibCheck": true,
-    "rewriteRelativeImportExtensions": true,
-    /* Bundler mode */
-    "moduleResolution": "bundler",
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "noEmit": false,
-    "declaration": true,
-    "outDir": "./dist",
-    "strict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noFallthroughCasesInSwitch": true
-  },
-  "include": ["src"],
-  "references": [{ "path": "./tsconfig.node.json" }]
-}

package/tsconfig.node.json

@@ -1,11 +0,0 @@
-{
-  "compilerOptions": {
-    "composite": true,
-    "skipLibCheck": true,
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "allowSyntheticDefaultImports": true,
-    "strict": true
-  },
-  "include": []
-}