api 4.5.0 → 5.0.0-beta.1

package/LICENSE

@@ -1,4 +1,4 @@
-Copyright © 2020 ReadMe
+Copyright © 2022 ReadMe
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the “Software”), to deal in

package/README.md

@@ -20,7 +20,7 @@ npm install api --save
 ```
 
 ## Usage
-Using `api` is as simple as supplying it an OpenAPI and using the SDK as you would any other!
+All you need to use `api` is to supply it an OpenAPI definition and then use the SDK as you would any other!
 
 ```js
 const sdk = require('api')('https://raw.githubusercontent.com/readmeio/oas-examples/main/3.0/json/petstore.json');
@@ -40,7 +40,7 @@ sdk.auth('myApiToken');
 sdk.listPets().then(...);
 ```
 
-With the exception of OpenID, it supports all forms of authentication supported by the OpenAPI specification! Just give `.auth()` your credentials and it'll figure out how to use it according to the API you're using.
+With the exception of OpenID, it supports all forms of authentication supported by the OpenAPI specification! Supply `.auth()` with your auth credentials and it'll magically figure out how to use it according to the API you're using. 🧙‍♀️
 
 For example:
 
@@ -56,7 +56,7 @@ When supplying parameters and/or request body payloads to an API request, you do
 * `body`: This will contain all data required for a request body payload for a POST, PUT, etc. request. It can either be an array or an object — whichever you need to use the API operation you're using.
 * `metadata`: This is an object where all parameters (path, query, header, cookie) go. Again, don't worry about telling the SDK that a path parameter is for the path, that's all handled for you.
 
-For example, if you wanted to make a simple GET request:
+For example, if you wanted to make a GET request:
 
 ```js
 sdk.showPetById({ petId: 1234 }).then(...)
@@ -143,7 +143,7 @@ At the moment it does not. If you wish to use an API that has a Swagger 2.0 file
 Not yet, unfortunately. For APIs that use OAuth 2, you'll need a fully-qualified token already for `api` to make requests.
 
 #### Does this support APIs that use multiple forms of authentication on a single request?
-Not yet! This is something we're thinking about how to handle, but it's difficult with the simple nature of the `.auth()` method as it currently does not require the user to inform the SDK of what kind of authentication scheme the token they're supplying it should match up against.
+Not yet! This is something we're thinking about how to handle, but it's difficult with the simplified nature of the `.auth()` method as it currently does not require the user to inform the SDK of what kind of authentication scheme the token they're supplying it should match up against.
 
 #### Will this work in browsers?
 Not at the moment as the library requires some filesystem handling in order to manage its cache state, but it's something we're actively thinking about. If you'd like to help us out in making this compatible with browsers we'd love to help you out on a pull request.
@@ -173,7 +173,6 @@ By default the cache is configured with the [find-cache-dir](https://npm.im/find
 const sdk = require('api')('https://raw.githubusercontent.com/readmeio/oas-examples/main/3.0/json/petstore.json', {
   cacheDir: './path/to/my/custom/cache/dir',
 });
-
 sdk.listPets().then(res => {
   console.log(`My pets name is ${res[0].name}!`);
 });

package/bin/api

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../dist/bin');

package/dist/bin.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bin.js

@@ -0,0 +1,91 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var commander_1 = require("commander");
+var pkg = __importStar(require("./packageInfo"));
+var commands_1 = __importDefault(require("./cli/commands"));
+(function () { return __awaiter(void 0, void 0, void 0, function () {
+    var program;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                program = new commander_1.Command();
+                program.name(pkg.PACKAGE_NAME);
+                program.version(pkg.PACKAGE_VERSION);
+                /**
+                 * Instead of using Commander's `executableDir` API for loading in external command files we're
+                 * programatically doing it like this because it's cleaner for us to let Commander manage option
+                 * and argument parsing within this file than having each command  manage that itself.
+                 */
+                Object.entries(commands_1["default"]).forEach(function (_a) {
+                    var cmd = _a[1];
+                    program.addCommand(cmd);
+                });
+                return [4 /*yield*/, program.parseAsync(process.argv)];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
+}); })();

package/dist/cache.d.ts

@@ -0,0 +1,30 @@
+import type { OASDocument } from 'oas/@types/rmoas.types';
+import 'isomorphic-fetch';
+import Fetcher from './fetcher';
+declare type CacheStore = Record<string, {
+    hash: string;
+    path?: string;
+    original: string | OASDocument;
+    title?: string;
+    version?: string;
+}>;
+export default class Cache {
+    static dir: string;
+    static cacheStore: string;
+    static specsCache: string;
+    uri: string | OASDocument;
+    uriHash: string;
+    cached: false | CacheStore;
+    fetcher: Fetcher;
+    constructor(uri: string | OASDocument, cacheDir?: string | false);
+    static getCacheHash(file: string | OASDocument): string;
+    static setCacheDir(dir?: string | false): void;
+    static reset(): Promise<void>;
+    static validate(json: any): Promise<import("openapi-types").OpenAPI.Document<{}>>;
+    isCached(): boolean;
+    getCache(): CacheStore;
+    get(): any;
+    load(): Promise<OASDocument>;
+    save(spec: OASDocument): OASDocument;
+}
+export {};

package/dist/cache.js

@@ -0,0 +1,217 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+require("isomorphic-fetch");
+var openapi_parser_1 = __importDefault(require("@readme/openapi-parser"));
+var crypto_1 = __importDefault(require("crypto"));
+var find_cache_dir_1 = __importDefault(require("find-cache-dir"));
+var fs_1 = __importDefault(require("fs"));
+var os_1 = __importDefault(require("os"));
+var path_1 = __importDefault(require("path"));
+var make_dir_1 = __importDefault(require("make-dir"));
+var packageInfo_1 = require("./packageInfo");
+var fetcher_1 = __importDefault(require("./fetcher"));
+var Cache = /** @class */ (function () {
+    function Cache(uri, cacheDir) {
+        if (cacheDir === void 0) { cacheDir = false; }
+        Cache.setCacheDir(cacheDir);
+        Cache.cacheStore = path_1["default"].join(Cache.dir, 'cache.json');
+        Cache.specsCache = path_1["default"].join(Cache.dir, 'specs');
+        this.fetcher = new fetcher_1["default"](uri);
+        this.uri = this.fetcher.uri;
+        this.uriHash = Cache.getCacheHash(this.uri);
+        // This should default to false so we have awareness if we've looked at the cache yet.
+        this.cached = false;
+    }
+    Cache.getCacheHash = function (file) {
+        var data;
+        if (typeof file === 'object') {
+            // Under certain unit testing circumstances, we might be supplying the class with a raw JSON
+            // object so we'll need to convert it to a string in order to hand it off to the crypto
+            // module.
+            data = JSON.stringify(file);
+        }
+        else {
+            data = file;
+        }
+        return crypto_1["default"].createHash('md5').update(data).digest('hex');
+    };
+    Cache.setCacheDir = function (dir) {
+        if (dir) {
+            Cache.dir = dir;
+            return;
+        }
+        else if (Cache.dir) {
+            // If we already have a cache dir set and aren't explicitly it to something new then we
+            // shouldn't overwrite what we've already got.
+            return;
+        }
+        Cache.dir = (0, find_cache_dir_1["default"])({ name: packageInfo_1.PACKAGE_NAME });
+        if (typeof Cache.dir === 'undefined') {
+            // The `find-cache-dir` module returns `undefined` if the `node_modules/` directory isn't
+            // writable, or there's no `package.json` in the root-most directory. If this happens, we can
+            // instead adhoc create a cache directory in the users OS temp directory and store our data
+            // there.
+            //
+            // @link https://github.com/avajs/find-cache-dir/issues/29
+            Cache.dir = make_dir_1["default"].sync(path_1["default"].join(os_1["default"].tmpdir(), packageInfo_1.PACKAGE_NAME));
+        }
+    };
+    Cache.reset = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!Cache.cacheStore) return [3 /*break*/, 2];
+                        return [4 /*yield*/, fs_1["default"].promises.rm(Cache.cacheStore)["catch"](function () {
+                                // no-op
+                            })];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        if (!Cache.specsCache) return [3 /*break*/, 4];
+                        return [4 /*yield*/, fs_1["default"].promises.rm(Cache.specsCache, { recursive: true })["catch"](function () {
+                                // no-op
+                            })];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Cache.validate = function (json) {
+        if (json.swagger) {
+            throw new Error('Sorry, this module only supports OpenAPI definitions.');
+        }
+        // The `validate` method handles dereferencing for us.
+        return openapi_parser_1["default"].validate(json, {
+            dereference: {
+                // If circular `$refs` are ignored they'll remain in the API definition as `$ref: String`.
+                // This allows us to not only do easy circular reference detection but also stringify and
+                // save dereferenced API definitions back into the cache directory.
+                circular: 'ignore'
+            }
+        })["catch"](function (err) {
+            if (/is not a valid openapi definition/i.test(err.message)) {
+                throw new Error("Sorry, that doesn't look like a valid OpenAPI definition.");
+            }
+            throw err;
+        });
+    };
+    Cache.prototype.isCached = function () {
+        var cache = this.getCache();
+        return cache && this.uriHash in cache;
+    };
+    Cache.prototype.getCache = function () {
+        if (typeof this.cached === 'object') {
+            return this.cached;
+        }
+        this.cached = {};
+        if (fs_1["default"].existsSync(Cache.cacheStore)) {
+            this.cached = JSON.parse(fs_1["default"].readFileSync(Cache.cacheStore, 'utf8'));
+        }
+        return this.cached;
+    };
+    Cache.prototype.get = function () {
+        // If the class was supplied a raw object, just go ahead and bypass the caching system and
+        // return that.
+        if (typeof this.uri === 'object') {
+            return this.uri;
+        }
+        if (!this.isCached()) {
+            throw new Error("".concat(this.uri, " has not been cached yet and must do so before being retrieved."));
+        }
+        var cache = this.getCache();
+        // Prior to v4.5.0 we were putting a fully resolved path to the API definition in the cache
+        // store but if you had specified a custom caching directory and would generate the cache on
+        // your system, that filepath would obviously not be the same in other environments. For this
+        // reason the `path` was removed from the cache store in favor of storing the `hash` instead.
+        //
+        // If we still have `path` in the config cache for backwards compatibility we should use it.
+        if ('path' in cache[this.uriHash]) {
+            return JSON.parse(fs_1["default"].readFileSync(cache[this.uriHash].path, 'utf8'));
+        }
+        return JSON.parse(fs_1["default"].readFileSync(path_1["default"].join(Cache.specsCache, "".concat(cache[this.uriHash].hash, ".json")), 'utf8'));
+    };
+    Cache.prototype.load = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                // If the class was supplied a raw object, just go ahead and bypass the caching system and
+                // return that.
+                if (typeof this.uri === 'object') {
+                    return [2 /*return*/, this.uri];
+                }
+                return [2 /*return*/, this.fetcher.load().then(function (spec) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/, this.save(spec)];
+                    }); }); })];
+            });
+        });
+    };
+    Cache.prototype.save = function (spec) {
+        if (!fs_1["default"].existsSync(Cache.dir)) {
+            fs_1["default"].mkdirSync(Cache.dir, { recursive: true });
+        }
+        if (!fs_1["default"].existsSync(Cache.specsCache)) {
+            fs_1["default"].mkdirSync(Cache.specsCache, { recursive: true });
+        }
+        var cache = this.getCache();
+        if (!(this.uriHash in cache)) {
+            var saved = JSON.stringify(spec, null, 2);
+            var fileHash = crypto_1["default"].createHash('md5').update(saved).digest('hex');
+            cache[this.uriHash] = {
+                hash: fileHash,
+                original: this.uri,
+                title: 'title' in spec.info ? spec.info.title : undefined,
+                version: 'version' in spec.info ? spec.info.version : undefined
+            };
+            fs_1["default"].writeFileSync(path_1["default"].join(Cache.specsCache, "".concat(fileHash, ".json")), saved);
+            fs_1["default"].writeFileSync(Cache.cacheStore, JSON.stringify(cache, null, 2));
+            this.cached = cache;
+        }
+        return spec;
+    };
+    return Cache;
+}());
+exports["default"] = Cache;

package/dist/cli/codegen/index.d.ts

@@ -0,0 +1,4 @@
+import type Oas from 'oas';
+import type CodeGeneratorLanguage from './language';
+export declare type SupportedLanguages = 'js' | 'js-cjs' | 'js-esm' | 'ts';
+export default function codegen(language: SupportedLanguages, spec: Oas, specPath: string, identifier: string): CodeGeneratorLanguage;

package/dist/cli/codegen/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var typescript_1 = __importDefault(require("./languages/typescript"));
+function codegen(language, spec, specPath, identifier) {
+    switch (language) {
+        case 'js':
+            throw new TypeError('An export format of CommonJS or ECMAScript is required for JavaScript compilation.');
+        case 'js-cjs':
+        case 'js-esm':
+        case 'ts':
+            return new typescript_1["default"](spec, specPath, identifier, {
+                outputJS: ['js-cjs', 'js-esm'].includes(language),
+                // TS will always generate with ESM-like exports.
+                compilerTarget: language === 'js-cjs' ? 'cjs' : 'esm'
+            });
+        default:
+            throw new TypeError("Unsupported language supplied: ".concat(language));
+    }
+}
+exports["default"] = codegen;

package/dist/cli/codegen/language.d.ts

@@ -0,0 +1,27 @@
+import type Oas from 'oas';
+import type Storage from '../storage';
+export interface InstallerOptions {
+    /**
+     * Will initiate a dry run install process. Used for simulating installations within a unit test.
+     */
+    dryRun?: boolean;
+    /**
+     * Used for stubbing out the logger that we use within the installation process so it can be
+     * easily introspected without having to mock out `console.*`.
+     */
+    logger?: (msg: string) => void;
+}
+export default abstract class CodeGeneratorLanguage {
+    spec: Oas;
+    specPath: string;
+    identifier: string;
+    userAgent: string;
+    requiredPackages: Record<string, {
+        reason: string;
+        url: string;
+    }>;
+    constructor(spec: Oas, specPath: string, identifier: string);
+    abstract generator(): Promise<Record<string, string>>;
+    abstract installer(storage: Storage, opts?: InstallerOptions): Promise<void>;
+    hasRequiredPackages(): boolean;
+}

package/dist/cli/codegen/language.js

@@ -0,0 +1,19 @@
+"use strict";
+exports.__esModule = true;
+var packageInfo_1 = require("../../packageInfo");
+var CodeGeneratorLanguage = /** @class */ (function () {
+    function CodeGeneratorLanguage(spec, specPath, identifier) {
+        this.spec = spec;
+        this.specPath = specPath;
+        // User agents should be contextual to the spec in question and the version of `api` that was
+        // used to generate the SDK. For example, this'll look like `petstore/1.0.0 (api/4.2.0)` for
+        // a `petstore` spec installed on api@4.2.0.
+        var info = spec.getDefinition().info;
+        this.userAgent = "".concat(identifier, "/").concat(info.version, " (").concat(packageInfo_1.PACKAGE_NAME, "/").concat(packageInfo_1.PACKAGE_VERSION, ")");
+    }
+    CodeGeneratorLanguage.prototype.hasRequiredPackages = function () {
+        return Boolean(Object.keys(this.requiredPackages));
+    };
+    return CodeGeneratorLanguage;
+}());
+exports["default"] = CodeGeneratorLanguage;

package/dist/cli/codegen/languages/typescript.d.ts

@@ -0,0 +1,99 @@
+import type Oas from 'oas';
+import type { Operation } from 'oas';
+import type { JSONSchema, SchemaObject } from 'oas/@types/rmoas.types';
+import type { ClassDeclaration, MethodDeclaration } from 'ts-morph';
+import type Storage from '../../storage';
+import type { InstallerOptions } from '../language';
+import CodeGeneratorLanguage from '../language';
+import { Project } from 'ts-morph';
+declare type OperationTypeHousing = {
+    types: {
+        params?: false | Record<'body' | 'formData' | 'metadata', string>;
+        responses?: Record<string, string>;
+    };
+    operation: Operation;
+};
+export default class TSGenerator extends CodeGeneratorLanguage {
+    project: Project;
+    outputJS: boolean;
+    compilerTarget: 'cjs' | 'esm';
+    types: Map<string, string>;
+    files: Record<string, string>;
+    methodGenerics: Map<string, MethodDeclaration>;
+    sdk: ClassDeclaration;
+    schemas: Map<string, {
+        schema: SchemaObject;
+        name: string;
+        tsType?: string;
+    }>;
+    constructor(spec: Oas, specPath: string, identifier: string, opts?: {
+        outputJS?: boolean;
+        compilerTarget?: 'cjs' | 'esm';
+    });
+    static formatter(content: string): string;
+    installer(storage: Storage, opts?: InstallerOptions): Promise<void>;
+    /**
+     * Compile the current OpenAPI definition into a TypeScript library.
+     *
+     */
+    generator(): Promise<{
+        [x: string]: string;
+    }>;
+    /**
+     * Create a generic HTTP method accessor on the SDK.
+     *
+     * @param method
+     */
+    createGenericMethodAccessor(method: string): void;
+    /**
+     * Create operation accessors on the SDK.
+     *
+     * @param operation
+     * @param operationId
+     * @param paramTypes
+     * @param responseTypes
+     */
+    createOperationAccessor(operation: Operation, operationId: string, paramTypes?: OperationTypeHousing['types']['params'], responseTypes?: OperationTypeHousing['types']['responses']): void;
+    /**
+     * Convert a JSON Schema object into a readily available TypeScript type or interface along with
+     * any `$ref` pointers that are in use and turn those into TS types too.
+     *
+     * Under the hood this uses https://npm.im/json-schema-to-typescript for all composition and
+     * conversion.
+     *
+     * @param schema
+     * @param name
+     */
+    convertJSONSchemaToTypescript(schema: JSONSchema, name: string): Promise<{
+        primaryType: string;
+    }>;
+    /**
+     * Scour through the current OpenAPI definition and compile a store of every operation, along
+     * with every HTTP method that's in use, and their available TypeScript types that we can use,
+     * along with every HTTP method that's in use.
+     *
+     */
+    loadOperationsAndMethods(): Promise<{
+        operations: Record<string, OperationTypeHousing>;
+        methods: Set<unknown>;
+    }>;
+    /**
+     * Compile the parameter (path, query, cookie, and header) schemas for an API operation into
+     * usable TypeScript types.
+     *
+     * @param operation
+     * @param operationId
+     */
+    prepareParameterTypesForOperation(operation: Operation, operationId: string): false | Record<"formData" | "body" | "metadata", string>;
+    /**
+     * Compile the response schemas for an API operation into usable TypeScript types.
+     *
+     * @todo what does this do for a spec that has no responses?
+     * @param operation
+     * @param operationId
+     */
+    prepareResponseTypesForOperation(operation: Operation, operationId: string): {
+        [x: string]: string;
+    };
+}
+export {};