@lorikeetai/node-sdk 0.1.0-beta.4 → 0.2.0

package/src/_shims/auto/runtime-bun.ts

@@ -1,4 +1,4 @@
 /**
  * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
  */
-export * from '../bun-runtime'
+export * from '../bun-runtime';

package/src/_shims/auto/runtime-node.ts

@@ -1,4 +1,4 @@
 /**
  * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
  */
-export * from '../node-runtime'
+export * from '../node-runtime';

package/src/_shims/auto/runtime.ts

@@ -1,4 +1,4 @@
 /**
  * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
  */
-export * from '../web-runtime'
+export * from '../web-runtime';

package/src/_shims/auto/types-node.ts

@@ -1,4 +1,4 @@
 /**
  * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
  */
-export * from '../node-types'
+export * from '../node-types';

package/src/_shims/auto/types.d.ts

@@ -1,101 +1,101 @@
 /**
  * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
  */
-export type Agent = any
+export type Agent = any;
 
 // @ts-ignore
-declare const _fetch:                                        typeof fetch
-export { _fetch as fetch }
+declare const _fetch:                                        typeof fetch;
+export { _fetch as fetch };
 
 // @ts-ignore
-type _Request =                                   Request
-export { _Request as Request }
+type _Request =                                   Request;
+export { _Request as Request };
 
 // @ts-ignore
-type _RequestInfo =                                       RequestInfo
-export { type _RequestInfo as RequestInfo }
+type _RequestInfo =                                       RequestInfo;
+export { type _RequestInfo as RequestInfo };
 
 // @ts-ignore
-type _RequestInit =                                       RequestInit
-export { type _RequestInit as RequestInit }
+type _RequestInit =                                       RequestInit;
+export { type _RequestInit as RequestInit };
 
 // @ts-ignore
-type _Response =                                    Response
-export { _Response as Response }
+type _Response =                                    Response;
+export { _Response as Response };
 
 // @ts-ignore
-type _ResponseInit =                                        ResponseInit
-export { type _ResponseInit as ResponseInit }
+type _ResponseInit =                                        ResponseInit;
+export { type _ResponseInit as ResponseInit };
 
 // @ts-ignore
-type _ResponseType =                                        ResponseType
-export { type _ResponseType as ResponseType }
+type _ResponseType =                                        ResponseType;
+export { type _ResponseType as ResponseType };
 
 // @ts-ignore
-type _BodyInit =                                    BodyInit
-export { type _BodyInit as BodyInit }
+type _BodyInit =                                    BodyInit;
+export { type _BodyInit as BodyInit };
 
 // @ts-ignore
-type _Headers =                                   Headers
-export { _Headers as Headers }
+type _Headers =                                   Headers;
+export { _Headers as Headers };
 
 // @ts-ignore
-type _HeadersInit =                                       HeadersInit
-export { type _HeadersInit as HeadersInit }
+type _HeadersInit =                                       HeadersInit;
+export { type _HeadersInit as HeadersInit };
 
-type EndingType = 'native' | 'transparent'
+type EndingType = 'native' | 'transparent';
 
 export interface BlobPropertyBag {
-  endings?: EndingType
-  type?: string
+  endings?: EndingType;
+  type?: string;
 }
 
 export interface FilePropertyBag extends BlobPropertyBag {
-  lastModified?: number
+  lastModified?: number;
 }
 
-export type FileFromPathOptions = Omit<FilePropertyBag, 'lastModified'>
+export type FileFromPathOptions = Omit<FilePropertyBag, 'lastModified'>;
 
 // @ts-ignore
-type _FormData =                                    FormData
+type _FormData =                                    FormData;
 // @ts-ignore
-declare const _FormData:                                           typeof FormData
-export { _FormData as FormData }
+declare const _FormData:                                           typeof FormData;
+export { _FormData as FormData };
 
 // @ts-ignore
-type _File =                                File
+type _File =                                File;
 // @ts-ignore
-declare const _File:                                       typeof File
-export { _File as File }
+declare const _File:                                       typeof File;
+export { _File as File };
 
 // @ts-ignore
-type _Blob =                                Blob
+type _Blob =                                Blob;
 // @ts-ignore
-declare const _Blob:                                       typeof Blob
-export { _Blob as Blob }
+declare const _Blob:                                       typeof Blob;
+export { _Blob as Blob };
 
 export declare class Readable {
-  readable: boolean
-  readonly readableEnded: boolean
-  readonly readableFlowing: boolean | null
-  readonly readableHighWaterMark: number
-  readonly readableLength: number
-  readonly readableObjectMode: boolean
-  destroyed: boolean
-  read(size?: number): any
-  pause(): this
-  resume(): this
-  isPaused(): boolean
-  destroy(error?: Error): this
-  [Symbol.asyncIterator](): AsyncIterableIterator<any>
+  readable: boolean;
+  readonly readableEnded: boolean;
+  readonly readableFlowing: boolean | null;
+  readonly readableHighWaterMark: number;
+  readonly readableLength: number;
+  readonly readableObjectMode: boolean;
+  destroyed: boolean;
+  read(size?: number): any;
+  pause(): this;
+  resume(): this;
+  isPaused(): boolean;
+  destroy(error?: Error): this;
+  [Symbol.asyncIterator](): AsyncIterableIterator<any>;
 }
 
 export declare class FsReadStream extends Readable {
-  path: {} // node type is string | Buffer
+  path: {}; // node type is string | Buffer
 }
 
 // @ts-ignore
-type _ReadableStream<R = any> =                                             ReadableStream<R>
+type _ReadableStream<R = any> =                                             ReadableStream<R>;
 // @ts-ignore
-declare const _ReadableStream:                                                 typeof ReadableStream
-export { _ReadableStream as ReadableStream }
+declare const _ReadableStream:                                                 typeof ReadableStream;
+export { _ReadableStream as ReadableStream };

package/src/_shims/bun-runtime.ts

@@ -1,14 +1,14 @@
 /**
  * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
  */
-import { type Shims } from './registry'
-import { getRuntime as getWebRuntime } from './web-runtime'
-import { ReadStream as FsReadStream } from 'node:fs'
+import { type Shims } from './registry';
+import { getRuntime as getWebRuntime } from './web-runtime';
+import { ReadStream as FsReadStream } from 'node:fs';
 
 export function getRuntime(): Shims {
-  const runtime = getWebRuntime()
+  const runtime = getWebRuntime();
   function isFsReadStream(value: any): value is FsReadStream {
-    return value instanceof FsReadStream
+    return value instanceof FsReadStream;
   }
-  return { ...runtime, isFsReadStream }
+  return { ...runtime, isFsReadStream };
 }

package/src/_shims/index.d.ts

@@ -1,81 +1,81 @@
 /**
  * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
  */
-import { manual } from './manual-types'
-import * as auto from "./auto/types"
-import { type RequestOptions } from '../core'
+import { manual } from './manual-types';
+import * as auto from "./auto/types";
+import { type RequestOptions } from '../core';
 
-type SelectType<Manual, Auto> = unknown extends Manual ? Auto : Manual
+type SelectType<Manual, Auto> = unknown extends Manual ? Auto : Manual;
 
-export const kind: string
+export const kind: string;
 
 // @ts-ignore
-export type Agent = SelectType<manual.Agent, auto.Agent>
+export type Agent = SelectType<manual.Agent, auto.Agent>;
 
 // @ts-ignore
-export const fetch: SelectType<typeof manual.fetch, typeof auto.fetch>
+export const fetch: SelectType<typeof manual.fetch, typeof auto.fetch>;
 
 // @ts-ignore
-export type Request = SelectType<manual.Request, auto.Request>
+export type Request = SelectType<manual.Request, auto.Request>;
 // @ts-ignore
-export type RequestInfo = SelectType<manual.RequestInfo, auto.RequestInfo>
+export type RequestInfo = SelectType<manual.RequestInfo, auto.RequestInfo>;
 // @ts-ignore
-export type RequestInit = SelectType<manual.RequestInit, auto.RequestInit>
+export type RequestInit = SelectType<manual.RequestInit, auto.RequestInit>;
 
 // @ts-ignore
-export type Response = SelectType<manual.Response, auto.Response>
+export type Response = SelectType<manual.Response, auto.Response>;
 // @ts-ignore
-export type ResponseInit = SelectType<manual.ResponseInit, auto.ResponseInit>
+export type ResponseInit = SelectType<manual.ResponseInit, auto.ResponseInit>;
 // @ts-ignore
-export type ResponseType = SelectType<manual.ResponseType, auto.ResponseType>
+export type ResponseType = SelectType<manual.ResponseType, auto.ResponseType>;
 // @ts-ignore
-export type BodyInit = SelectType<manual.BodyInit, auto.BodyInit>
+export type BodyInit = SelectType<manual.BodyInit, auto.BodyInit>;
 // @ts-ignore
-export type Headers = SelectType<manual.Headers, auto.Headers>
+export type Headers = SelectType<manual.Headers, auto.Headers>;
 // @ts-ignore
-export const Headers: SelectType<typeof manual.Headers, typeof auto.Headers>
+export const Headers: SelectType<typeof manual.Headers, typeof auto.Headers>;
 // @ts-ignore
-export type HeadersInit = SelectType<manual.HeadersInit, auto.HeadersInit>
+export type HeadersInit = SelectType<manual.HeadersInit, auto.HeadersInit>;
 
 // @ts-ignore
-export type BlobPropertyBag = SelectType<manual.BlobPropertyBag, auto.BlobPropertyBag>
+export type BlobPropertyBag = SelectType<manual.BlobPropertyBag, auto.BlobPropertyBag>;
 // @ts-ignore
-export type FilePropertyBag = SelectType<manual.FilePropertyBag, auto.FilePropertyBag>
+export type FilePropertyBag = SelectType<manual.FilePropertyBag, auto.FilePropertyBag>;
 // @ts-ignore
-export type FileFromPathOptions = SelectType<manual.FileFromPathOptions, auto.FileFromPathOptions>
+export type FileFromPathOptions = SelectType<manual.FileFromPathOptions, auto.FileFromPathOptions>;
 // @ts-ignore
-export type FormData = SelectType<manual.FormData, auto.FormData>
+export type FormData = SelectType<manual.FormData, auto.FormData>;
 // @ts-ignore
-export const FormData: SelectType<typeof manual.FormData, typeof auto.FormData>
+export const FormData: SelectType<typeof manual.FormData, typeof auto.FormData>;
 // @ts-ignore
-export type File = SelectType<manual.File, auto.File>
+export type File = SelectType<manual.File, auto.File>;
 // @ts-ignore
-export const File: SelectType<typeof manual.File, typeof auto.File>
+export const File: SelectType<typeof manual.File, typeof auto.File>;
 // @ts-ignore
-export type Blob = SelectType<manual.Blob, auto.Blob>
+export type Blob = SelectType<manual.Blob, auto.Blob>;
 // @ts-ignore
-export const Blob: SelectType<typeof manual.Blob, typeof auto.Blob>
+export const Blob: SelectType<typeof manual.Blob, typeof auto.Blob>;
 
 // @ts-ignore
-export type Readable = SelectType<manual.Readable, auto.Readable>
+export type Readable = SelectType<manual.Readable, auto.Readable>;
 // @ts-ignore
-export type FsReadStream = SelectType<manual.FsReadStream, auto.FsReadStream>
+export type FsReadStream = SelectType<manual.FsReadStream, auto.FsReadStream>;
 // @ts-ignore
-export type ReadableStream = SelectType<manual.ReadableStream, auto.ReadableStream>
+export type ReadableStream = SelectType<manual.ReadableStream, auto.ReadableStream>;
 // @ts-ignore
-export const ReadableStream: SelectType<typeof manual.ReadableStream, typeof auto.ReadableStream>
+export const ReadableStream: SelectType<typeof manual.ReadableStream, typeof auto.ReadableStream>;
 
 export function getMultipartRequestOptions<T = Record<string, unknown>>(
   form: FormData,
   opts: RequestOptions<T>,
-): Promise<RequestOptions<T>>
+): Promise<RequestOptions<T>>;
 
-export function getDefaultAgent(url: string): any
+export function getDefaultAgent(url: string): any;
 
 // @ts-ignore
-export type FileFromPathOptions = SelectType<manual.FileFromPathOptions, auto.FileFromPathOptions>
+export type FileFromPathOptions = SelectType<manual.FileFromPathOptions, auto.FileFromPathOptions>;
 
-export function fileFromPath(path: string, options?: FileFromPathOptions): Promise<File>
-export function fileFromPath(path: string, filename?: string, options?: FileFromPathOptions): Promise<File>
+export function fileFromPath(path: string, options?: FileFromPathOptions): Promise<File>;
+export function fileFromPath(path: string, filename?: string, options?: FileFromPathOptions): Promise<File>;
 
-export function isFsReadStream(value: any): value is FsReadStream
+export function isFsReadStream(value: any): value is FsReadStream;

package/src/_shims/index.js

@@ -1,13 +1,13 @@
 /**
  * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
  */
-const shims = require('./registry')
-const auto = require('@lorikeetai/node-sdk/_shims/auto/runtime')
-if (!shims.kind) shims.setShims(auto.getRuntime(), { auto: true })
+const shims = require('./registry');
+const auto = require('@lorikeetai/node-sdk/_shims/auto/runtime');
+if (!shims.kind) shims.setShims(auto.getRuntime(), { auto: true });
 for (const property of Object.keys(shims)) {
   Object.defineProperty(exports, property, {
     get() {
-      return shims[property]
+      return shims[property];
     },
-  })
+  });
 }

package/src/_shims/index.mjs

@@ -1,7 +1,7 @@
 /**
  * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
  */
-import * as shims from './registry.mjs'
-import * as auto from "./auto/runtime"
-if (!shims.kind) shims.setShims(auto.getRuntime(), { auto: true })
-export * from './registry.mjs'
+import * as shims from './registry.mjs';
+import * as auto from "./auto/runtime";
+if (!shims.kind) shims.setShims(auto.getRuntime(), { auto: true });
+export * from './registry.mjs';

package/src/_shims/node-runtime.ts

@@ -1,67 +1,67 @@
 /**
  * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
  */
-import * as nf from 'node-fetch'
-import * as fd from 'formdata-node'
-import { type File, type FilePropertyBag } from 'formdata-node'
-import KeepAliveAgent from 'agentkeepalive'
-import { AbortController as AbortControllerPolyfill } from 'abort-controller'
-import { ReadStream as FsReadStream } from 'node:fs'
-import { type Agent } from 'node:http'
-import { FormDataEncoder } from 'form-data-encoder'
-import { Readable } from 'node:stream'
-import { type RequestOptions } from '../core'
-import { MultipartBody } from './MultipartBody'
-import { type Shims } from './registry'
-import { ReadableStream } from 'node:stream/web'
+import * as nf from 'node-fetch';
+import * as fd from 'formdata-node';
+import { type File, type FilePropertyBag } from 'formdata-node';
+import KeepAliveAgent from 'agentkeepalive';
+import { AbortController as AbortControllerPolyfill } from 'abort-controller';
+import { ReadStream as FsReadStream } from 'node:fs';
+import { type Agent } from 'node:http';
+import { FormDataEncoder } from 'form-data-encoder';
+import { Readable } from 'node:stream';
+import { type RequestOptions } from '../core';
+import { MultipartBody } from './MultipartBody';
+import { type Shims } from './registry';
+import { ReadableStream } from 'node:stream/web';
 
-type FileFromPathOptions = Omit<FilePropertyBag, 'lastModified'>
+type FileFromPathOptions = Omit<FilePropertyBag, 'lastModified'>;
 
-let fileFromPathWarned = false
+let fileFromPathWarned = false;
 
 /**
  * @deprecated use fs.createReadStream('./my/file.txt') instead
  */
-async function fileFromPath(path: string): Promise<File>
-async function fileFromPath(path: string, filename?: string): Promise<File>
-async function fileFromPath(path: string, options?: FileFromPathOptions): Promise<File>
-async function fileFromPath(path: string, filename?: string, options?: FileFromPathOptions): Promise<File>
+async function fileFromPath(path: string): Promise<File>;
+async function fileFromPath(path: string, filename?: string): Promise<File>;
+async function fileFromPath(path: string, options?: FileFromPathOptions): Promise<File>;
+async function fileFromPath(path: string, filename?: string, options?: FileFromPathOptions): Promise<File>;
 async function fileFromPath(path: string, ...args: any[]): Promise<File> {
   // this import fails in environments that don't handle export maps correctly, like old versions of Jest
-  const { fileFromPath: _fileFromPath } = await import('formdata-node/file-from-path')
+  const { fileFromPath: _fileFromPath } = await import('formdata-node/file-from-path');
 
   if (!fileFromPathWarned) {
-    console.warn(`fileFromPath is deprecated; use fs.createReadStream(${JSON.stringify(path)}) instead`)
-    fileFromPathWarned = true
+    console.warn(`fileFromPath is deprecated; use fs.createReadStream(${JSON.stringify(path)}) instead`);
+    fileFromPathWarned = true;
   }
   // @ts-ignore
-  return await _fileFromPath(path, ...args)
+  return await _fileFromPath(path, ...args);
 }
 
-const defaultHttpAgent: Agent = new KeepAliveAgent({ keepAlive: true, timeout: 5 * 60 * 1000 })
-const defaultHttpsAgent: Agent = new KeepAliveAgent.HttpsAgent({ keepAlive: true, timeout: 5 * 60 * 1000 })
+const defaultHttpAgent: Agent = new KeepAliveAgent({ keepAlive: true, timeout: 5 * 60 * 1000 });
+const defaultHttpsAgent: Agent = new KeepAliveAgent.HttpsAgent({ keepAlive: true, timeout: 5 * 60 * 1000 });
 
 async function getMultipartRequestOptions<T = Record<string, unknown>>(
   form: fd.FormData,
   opts: RequestOptions<T>,
 ): Promise<RequestOptions<T>> {
-  const encoder = new FormDataEncoder(form)
-  const readable = Readable.from(encoder)
-  const body = new MultipartBody(readable)
+  const encoder = new FormDataEncoder(form);
+  const readable = Readable.from(encoder);
+  const body = new MultipartBody(readable);
   const headers = {
     ...opts.headers,
     ...encoder.headers,
     'Content-Length': encoder.contentLength,
-  }
+  };
 
-  return { ...opts, body: body as any, headers }
+  return { ...opts, body: body as any, headers };
 }
 
 export function getRuntime(): Shims {
   // Polyfill global object if needed.
   if (typeof AbortController === 'undefined') {
     // @ts-expect-error (the types are subtly different, but compatible in practice)
-    globalThis.AbortController = AbortControllerPolyfill
+    globalThis.AbortController = AbortControllerPolyfill;
   }
   return {
     kind: 'node',
@@ -77,5 +77,5 @@ export function getRuntime(): Shims {
     getDefaultAgent: (url: string): Agent => (url.startsWith('https') ? defaultHttpsAgent : defaultHttpAgent),
     fileFromPath,
     isFsReadStream: (value: any): value is FsReadStream => value instanceof FsReadStream,
-  }
+  };
 }

package/src/_shims/node-types.d.ts

@@ -1,42 +1,42 @@
 /**
  * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
  */
-import * as nf from 'node-fetch'
-import * as fd from 'formdata-node'
+import * as nf from 'node-fetch';
+import * as fd from 'formdata-node';
 
-export { type Agent } from 'node:http'
-export { type Readable } from 'node:stream'
-export { type ReadStream as FsReadStream } from 'node:fs'
-export { ReadableStream } from 'node:stream/web'
+export { type Agent } from 'node:http';
+export { type Readable } from 'node:stream';
+export { type ReadStream as FsReadStream } from 'node:fs';
+export { ReadableStream } from 'node:stream/web';
 
-export const fetch: typeof nf.default
+export const fetch: typeof nf.default;
 
-export type Request = nf.Request
-export type RequestInfo = nf.RequestInfo
-export type RequestInit = nf.RequestInit
+export type Request = nf.Request;
+export type RequestInfo = nf.RequestInfo;
+export type RequestInit = nf.RequestInit;
 
-export type Response = nf.Response
-export type ResponseInit = nf.ResponseInit
-export type ResponseType = nf.ResponseType
-export type BodyInit = nf.BodyInit
-export type Headers = nf.Headers
-export type HeadersInit = nf.HeadersInit
+export type Response = nf.Response;
+export type ResponseInit = nf.ResponseInit;
+export type ResponseType = nf.ResponseType;
+export type BodyInit = nf.BodyInit;
+export type Headers = nf.Headers;
+export type HeadersInit = nf.HeadersInit;
 
-type EndingType = 'native' | 'transparent'
+type EndingType = 'native' | 'transparent';
 export interface BlobPropertyBag {
-  endings?: EndingType
-  type?: string
+  endings?: EndingType;
+  type?: string;
 }
 
 export interface FilePropertyBag extends BlobPropertyBag {
-  lastModified?: number
+  lastModified?: number;
 }
 
-export type FileFromPathOptions = Omit<FilePropertyBag, 'lastModified'>
+export type FileFromPathOptions = Omit<FilePropertyBag, 'lastModified'>;
 
-export type FormData = fd.FormData
-export const FormData: typeof fd.FormData
-export type File = fd.File
-export const File: typeof fd.File
-export type Blob = fd.Blob
-export const Blob: typeof fd.Blob
+export type FormData = fd.FormData;
+export const FormData: typeof fd.FormData;
+export type File = fd.File;
+export const File: typeof fd.File;
+export type Blob = fd.Blob;
+export const Blob: typeof fd.Blob;

package/src/_shims/registry.ts

@@ -1,67 +1,67 @@
 /**
  * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
  */
-import { type RequestOptions } from '../core'
+import { type RequestOptions } from '../core';
 
 export interface Shims {
-  kind: string
-  fetch: any
-  Request: any
-  Response: any
-  Headers: any
-  FormData: any
-  Blob: any
-  File: any
-  ReadableStream: any
+  kind: string;
+  fetch: any;
+  Request: any;
+  Response: any;
+  Headers: any;
+  FormData: any;
+  Blob: any;
+  File: any;
+  ReadableStream: any;
   getMultipartRequestOptions: <T = Record<string, unknown>>(
     form: Shims['FormData'],
     opts: RequestOptions<T>,
-  ) => Promise<RequestOptions<T>>
-  getDefaultAgent: (url: string) => any
+  ) => Promise<RequestOptions<T>>;
+  getDefaultAgent: (url: string) => any;
   fileFromPath:
     | ((path: string, filename?: string, options?: {}) => Promise<Shims['File']>)
-    | ((path: string, options?: {}) => Promise<Shims['File']>)
-  isFsReadStream: (value: any) => boolean
+    | ((path: string, options?: {}) => Promise<Shims['File']>);
+  isFsReadStream: (value: any) => boolean;
 }
 
-export let auto = false
-export let kind: Shims['kind'] | undefined = undefined
-export let fetch: Shims['fetch'] | undefined = undefined
-export let Request: Shims['Request'] | undefined = undefined
-export let Response: Shims['Response'] | undefined = undefined
-export let Headers: Shims['Headers'] | undefined = undefined
-export let FormData: Shims['FormData'] | undefined = undefined
-export let Blob: Shims['Blob'] | undefined = undefined
-export let File: Shims['File'] | undefined = undefined
-export let ReadableStream: Shims['ReadableStream'] | undefined = undefined
-export let getMultipartRequestOptions: Shims['getMultipartRequestOptions'] | undefined = undefined
-export let getDefaultAgent: Shims['getDefaultAgent'] | undefined = undefined
-export let fileFromPath: Shims['fileFromPath'] | undefined = undefined
-export let isFsReadStream: Shims['isFsReadStream'] | undefined = undefined
+export let auto = false;
+export let kind: Shims['kind'] | undefined = undefined;
+export let fetch: Shims['fetch'] | undefined = undefined;
+export let Request: Shims['Request'] | undefined = undefined;
+export let Response: Shims['Response'] | undefined = undefined;
+export let Headers: Shims['Headers'] | undefined = undefined;
+export let FormData: Shims['FormData'] | undefined = undefined;
+export let Blob: Shims['Blob'] | undefined = undefined;
+export let File: Shims['File'] | undefined = undefined;
+export let ReadableStream: Shims['ReadableStream'] | undefined = undefined;
+export let getMultipartRequestOptions: Shims['getMultipartRequestOptions'] | undefined = undefined;
+export let getDefaultAgent: Shims['getDefaultAgent'] | undefined = undefined;
+export let fileFromPath: Shims['fileFromPath'] | undefined = undefined;
+export let isFsReadStream: Shims['isFsReadStream'] | undefined = undefined;
 
 export function setShims(shims: Shims, options: { auto: boolean } = { auto: false }) {
   if (auto) {
     throw new Error(
       `you must \`import '@lorikeetai/node-sdk/shims/${shims.kind}'\` before importing anything else from @lorikeetai/node-sdk`,
-    )
+    );
   }
   if (kind) {
     throw new Error(
       `can't \`import '@lorikeetai/node-sdk/shims/${shims.kind}'\` after \`import '@lorikeetai/node-sdk/shims/${kind}'\``,
-    )
+    );
   }
-  auto = options.auto
-  kind = shims.kind
-  fetch = shims.fetch
-  Request = shims.Request
-  Response = shims.Response
-  Headers = shims.Headers
-  FormData = shims.FormData
-  Blob = shims.Blob
-  File = shims.File
-  ReadableStream = shims.ReadableStream
-  getMultipartRequestOptions = shims.getMultipartRequestOptions
-  getDefaultAgent = shims.getDefaultAgent
-  fileFromPath = shims.fileFromPath
-  isFsReadStream = shims.isFsReadStream
+  auto = options.auto;
+  kind = shims.kind;
+  fetch = shims.fetch;
+  Request = shims.Request;
+  Response = shims.Response;
+  Headers = shims.Headers;
+  FormData = shims.FormData;
+  Blob = shims.Blob;
+  File = shims.File;
+  ReadableStream = shims.ReadableStream;
+  getMultipartRequestOptions = shims.getMultipartRequestOptions;
+  getDefaultAgent = shims.getDefaultAgent;
+  fileFromPath = shims.fileFromPath;
+  isFsReadStream = shims.isFsReadStream;
 }