@volant-autonomy/via-sdk 1.0.1

package/dist/direct.js

@@ -0,0 +1,300 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Direct = void 0;
+class Direct {
+    constructor(fetcher) {
+        this.fetcher = fetcher;
+    }
+    /// flightplans
+    getAllFlightplans(filters, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.GET('/flightplans/', { query: { 'filter[state]': filters } }, opts);
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data.map((flightplan) => flightplan.data) });
+            }
+            else {
+                return resp;
+            }
+        });
+    }
+    createDraftFlightplan(args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.POST('/flightplans/', { body: args }, opts);
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+            }
+            return resp;
+        });
+    }
+    modifyDraftFlightplan(id, args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.PUT('/flightplans/{flightplan_id}', { body: args, path: { flightplan_id: id } }, opts);
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+            }
+            return resp;
+        });
+    }
+    getFlightplan(id, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.GET('/flightplans/{flightplan_id}', { path: { flightplan_id: id } }, opts);
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+            }
+            return resp;
+        });
+    }
+    // FIXME: this name is poor
+    getFlightplanWaypointsDetailed(id, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.GET('/flightplans/{flightplan_id}/waypoints_detail', { path: { flightplan_id: id } }, opts);
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+            }
+            return resp;
+        });
+    }
+    getFlightplanStatistics(id, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.GET('/flightplans/{flightplan_id}/statistics', { path: { flightplan_id: id } }, opts);
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+            }
+            return resp;
+        });
+    }
+    getFlightplanVolumes(id, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.GET('/flightplans/{flightplan_id}/volumes', { path: { flightplan_id: id } }, opts);
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+            }
+            return resp;
+        });
+    }
+    getFlightplanConflicts(id, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.GET('/flightplans/{flightplan_id}/conflicts', { path: { flightplan_id: id } }, opts);
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+            }
+            return resp;
+        });
+    }
+    // TODO: make a wrapper for this which updates the existing flightplan to have this new start time
+    getFlightplanDeconflictedStartTime(id, args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.GET('/flightplans/{flightplan_id}/start_time_deconflict', { path: { flightplan_id: id }, query: args }, opts);
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+            }
+            return resp;
+        });
+    }
+    changeFlightplanState(id, state, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.POST('/flightplans/{flightplan_id}/state', { path: { flightplan_id: id }, body: { state } }, opts);
+            if (!resp.error && resp.aborted === false) {
+                return Object.assign(Object.assign({}, resp), { data: true });
+            }
+            return resp;
+        });
+    }
+    // TODO: use `args` instead of fileFormat
+    getFlightplanAsFile(id, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.GET('/flightplans/{flightplan_id}/content', { path: { flightplan_id: id }, header: { accept: 'application/vnd.google-earth.kml+xml' } }, Object.assign(Object.assign({}, opts), { parseAs: 'blob' }));
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: { file: resp.data, fileName: resp.response.headers.get('filename') } });
+            }
+            return resp;
+        });
+    }
+    /// airspace constraints
+    createAirspaceConstraint(args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.POST('/airspace_constraints/', { body: args }, opts);
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+            }
+            return resp;
+        });
+    }
+    getAllAirspaceConstraints(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.GET('/airspace_constraints/', {}, opts);
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data.map((constraint) => constraint.data) });
+            }
+            return resp;
+        });
+    }
+    getAirspaceConstraint(id, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.GET('/airspace_constraints/{airspace_constraint_id}', { path: { airspace_constraint_id: id } }, opts);
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+            }
+            return resp;
+        });
+    }
+    modifyAirspaceConstraint(id, args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.PUT('/airspace_constraints/{airspace_constraint_id}', { path: { airspace_constraint_id: id }, body: args }, opts);
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+            }
+            return resp;
+        });
+    }
+    changeAirspaceConstraintState(id, state, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.POST('/airspace_constraints/{airspace_constraints_id}/state', { path: { airspace_constraints_id: id }, body: { state } }, opts);
+            if (!resp.error && resp.aborted === false) {
+                return Object.assign(Object.assign({}, resp), { data: true });
+            }
+            return resp;
+        });
+    }
+    /// pathing tasks
+    createPathingTask(args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.POST('/pathing_tasks/', { body: args }, opts);
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+            }
+            return resp;
+        });
+    }
+    getPathingTask(id, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.GET('/pathing_tasks/{pathing_task_id}', { path: { pathing_task_id: id } }, opts);
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+            }
+            return resp;
+        });
+    }
+    /// aircraft
+    getAllAircraft(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.GET('/aircraft/', {}, opts);
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data.map((aircraft) => aircraft.data) });
+            }
+            return resp;
+        });
+    }
+    getAircraft(id, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.GET('/aircraft/{aircraft_id}', { path: { aircraft_id: id } }, opts);
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+            }
+            return resp;
+        });
+    }
+    /// charts
+    getAllCharts(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.GET('/charts/', {}, opts);
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data.map((chart) => chart.data) });
+            }
+            return resp;
+        });
+    }
+    getChart(id, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.GET('/charts/{chart_id}', { path: { chart_id: id } }, opts);
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+            }
+            return resp;
+        });
+    }
+    /// risk assessment
+    calculateSailV2_5(args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.GET('/risk_assessment/sora/v2.5/sail', { query: args }, opts);
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+            }
+            return resp;
+        });
+    }
+    getAllArcsV2_5(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.GET('/risk_assessment/sora/v2.5/air_risk_classifications', {}, opts);
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+            }
+            return resp;
+        });
+    }
+    getArcInfoV2_5(args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.GET('/risk_assessment/sora/v2.5/air_risk_classifications/{arc_id}', { path: args }, opts);
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+            }
+            return resp;
+        });
+    }
+    createSoraReportV2_5(args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.POST('/risk_assessment/sora/v2.5/report', { body: args }, opts);
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+            }
+            return resp;
+        });
+    }
+    createSoraSemanticModelVolumesV2_5(args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.POST('/risk_assessment/sora/v2.5/semantic_model_volumes', { body: args }, opts);
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+            }
+            return resp;
+        });
+    }
+    createSoraClassification(args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.POST('/risk_assessment/sora/classifications', { body: args }, opts);
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+            }
+            return resp;
+        });
+    }
+    getSoraClassification(args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.GET('/risk_assessment/sora/classifications/{classification_id}', { path: args }, opts);
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+            }
+            return resp;
+        });
+    }
+    /// flight patterns
+    createRasterPattern(args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.fetcher.POST('/flight_patterns/raster', { body: args }, opts);
+            if (resp.error === undefined && !resp.aborted) {
+                return Object.assign(Object.assign({}, resp), { data: resp.data.data });
+            }
+            return resp;
+        });
+    }
+}
+exports.Direct = Direct;

package/dist/docstringTransformer.d.ts

@@ -0,0 +1,3 @@
+import type { TransformerExtras, PluginConfig } from 'ts-patch';
+import type ts from 'typescript';
+export default function (program: ts.Program, _pluginConfig: PluginConfig, { ts: tsInstance }: TransformerExtras): ts.TransformerFactory<ts.SourceFile>;

package/dist/docstringTransformer.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+/**
+ * Follows the 'paths' import to get a mapping of endpoint -> docstrings from the schema file.
+ * The relevant part of the schema is in the shape below
+ *   @example
+ *   interface paths {
+ *     "/endpoint": {
+ *       // docstring
+ *       put: data;
+ *       // docstring
+ *       post: data;
+ *     }
+ *  }
+ */
+function gatherDocstrings(node, tsInstance, program) {
+    var _a;
+    // if the current node is not an import, search this node's children
+    if (!tsInstance.isImportDeclaration(node) || !tsInstance.isStringLiteral(node.moduleSpecifier)) {
+        // forEachChild handles early returns for us
+        return node.forEachChild((child) => {
+            return gatherDocstrings(child, tsInstance, program);
+        });
+    }
+    const endpointDocstrings = {};
+    const typeChecker = program.getTypeChecker();
+    const importSymbol = typeChecker.getSymbolAtLocation(node.moduleSpecifier);
+    // if this import is not the schema, stop
+    if (!(importSymbol === null || importSymbol === void 0 ? void 0 : importSymbol.getName().includes('schema')))
+        return;
+    const exportSymbols = typeChecker.getExportsOfModule(importSymbol);
+    for (const rootSymbol of exportSymbols) {
+        if (rootSymbol.getName() === 'paths') {
+            if (rootSymbol.members === undefined) {
+                console.error('Paths has no members. Something is strange in the schema.ts file.');
+                return;
+            }
+            // iterate over each of the paths
+            for (const [pathStr, pathSymbol] of rootSymbol.members.entries()) {
+                (_a = pathSymbol.valueDeclaration) === null || _a === void 0 ? void 0 : _a.forEachChild((pathLiteral) => {
+                    var _a, _b, _c;
+                    if (!tsInstance.isTypeLiteralNode(pathLiteral)) {
+                        return;
+                    }
+                    for (const methodSymbol of pathLiteral.members) {
+                        const docstring = (_a = methodSymbol === null || methodSymbol === void 0 ? void 0 : methodSymbol.jsDoc) === null || _a === void 0 ? void 0 : _a.map((x) => 
+                        // getFullText includes the /** and */ lines, which we do not want
+                        // this strips them out
+                        x
+                            .getFullText()
+                            .split('\n')
+                            .slice(1, -1)
+                            .map((x) => ' ' + x.trim())
+                            .join('\n'));
+                        const method = (_b = methodSymbol === null || methodSymbol === void 0 ? void 0 : methodSymbol.name) === null || _b === void 0 ? void 0 : _b.getText();
+                        if (method) {
+                            const path = pathStr.toString();
+                            (_c = endpointDocstrings[path]) !== null && _c !== void 0 ? _c : (endpointDocstrings[path] = {});
+                            endpointDocstrings[path][method] = docstring;
+                        }
+                    }
+                });
+            }
+            return endpointDocstrings;
+        }
+    }
+    return undefined;
+}
+/**
+ * Uses the types with the same names as the functions to get the mapping of endpoints -> function identifiers
+ * Looks for this shape: `type ident = source['path']['method']` (where source = 'paths')
+ * @description Which in the ast is (ignoring irrelevant properties):
+ * @example
+ * TypeAliasDeclaration<
+ *   Identifier<ident>,
+ *   IndexedAccessType<
+ *     IndexedAccessType<
+ *       TypeReference<source>, LiteralType<path>
+ *     >,
+ *    LiteralType<method>
+ *   >
+ * >
+ */
+function gatherIdentifiers(node, identifiers, tsInstance, program) {
+    var _a;
+    // if the current node is not a type alias, continue searching
+    if (!tsInstance.isTypeAliasDeclaration(node)) {
+        node.forEachChild((child) => {
+            gatherIdentifiers(child, identifiers, tsInstance, program);
+        });
+        return identifiers;
+    }
+    // name of the function
+    let identifier;
+    let next1;
+    node.forEachChild((n) => {
+        if (tsInstance.isIndexedAccessTypeNode(n))
+            next1 = n;
+        if (tsInstance.isIdentifier(n))
+            identifier = n.getText();
+    });
+    if (identifier === undefined || next1 === undefined)
+        return;
+    // the html request method
+    let method;
+    let next2;
+    next1.forEachChild((n) => {
+        if (tsInstance.isIndexedAccessTypeNode(n))
+            next2 = n;
+        if (tsInstance.isLiteralTypeNode(n))
+            method = n.literal.getText().slice(1, -1); // FIXME:
+    });
+    if (method === undefined || next2 === undefined)
+        return;
+    // type object getting indexed, should be paths
+    let source;
+    // the path of the api being called
+    let path;
+    next2.forEachChild((n) => {
+        if (tsInstance.isTypeReferenceNode(n))
+            source = n;
+        if (tsInstance.isLiteralTypeNode(n))
+            path = n.literal.getText().slice(1, -1); // FIXME:
+    });
+    if ((source === null || source === void 0 ? void 0 : source.getText()) !== 'paths') {
+        console.error(`Source was not 'paths' for method '${identifier}' it was '${source === null || source === void 0 ? void 0 : source.getText()}'. Was indexed with ${path} / ${method}`);
+        return;
+    }
+    if (path === undefined)
+        return;
+    const constPath = path; // typescript refuses to accept this as valid unless path is const
+    (_a = identifiers[constPath]) !== null && _a !== void 0 ? _a : (identifiers[constPath] = {});
+    identifiers[constPath][method] = identifier;
+    return identifiers;
+}
+function default_1(program, _pluginConfig, { ts: tsInstance }) {
+    return (ctx) => {
+        return (sourceFile) => {
+            var _a;
+            if (!sourceFile.fileName.includes('direct')) {
+                return sourceFile;
+            }
+            // TODO: this ignores -s. find something that doesn't
+            // console.log(`> Applying docstring transform on ${sourceFile?.fileName}`)
+            const endpointDocstrings = gatherDocstrings(sourceFile, tsInstance, program);
+            if (endpointDocstrings === undefined) {
+                console.error('endpoint docstrings were not found');
+                return sourceFile;
+            }
+            const endpointIdentifiers = gatherIdentifiers(sourceFile, {}, tsInstance, program);
+            if (endpointIdentifiers === undefined) {
+                console.error('endpoint -> identifiers were not found');
+                return sourceFile;
+            }
+            const identifierDocstrings = {};
+            // for each of the identifiers defined in the file, find their associated docstring
+            for (const [path, methods] of Object.entries(endpointIdentifiers)) {
+                for (const [method, identifier] of Object.entries(methods)) {
+                    identifierDocstrings[identifier] = (_a = endpointDocstrings[path]) === null || _a === void 0 ? void 0 : _a[method];
+                }
+            }
+            function applyDocstrings(node) {
+                if (!tsInstance.isMethodDeclaration(node)) {
+                    return tsInstance.visitEachChild(node, applyDocstrings, ctx); // continue searching
+                }
+                const name = node.name.getText();
+                const text = identifierDocstrings[name];
+                if (text) {
+                    // FIXME: find out what happens if text.length > 2
+                    tsInstance.setSyntheticLeadingComments(node, text.map((text) => {
+                        return {
+                            // type definition says these have to be -1
+                            pos: -1,
+                            end: -1,
+                            hasTrailingNewLine: true,
+                            // the first line of the resulting synthetic comment gets a `/*` at the start,
+                            // so adding `*\n` makes it `/**`, a jsdoc comment
+                            text: '*\n' + text + '\n ',
+                            kind: tsInstance.SyntaxKind.MultiLineCommentTrivia
+                        };
+                    }));
+                }
+                return node;
+            }
+            return tsInstance.visitNode(sourceFile, applyDocstrings);
+        };
+    };
+}

package/dist/fetch.d.ts

@@ -0,0 +1,123 @@
+import { ParseAs, ParseAsResponse } from 'openapi-fetch';
+import { HttpMethod, PathsWithMethod, HasRequiredKeys, FilterKeys, SuccessResponse, ResponseObjectMap, OkStatus } from 'openapi-typescript-helpers';
+import { Expand, bodyOf } from './types';
+type requestOptions = {
+    abortKey?: string;
+    fetch?: typeof globalThis.fetch;
+    parseAs?: ParseAs;
+};
+/**
+ * Get the types of the parameters of an endpoint but if it does not have any
+ * typing for some reason then fallback to a reasonable default
+ */
+type ParamsOption<T> = T extends {
+    parameters: any;
+} ? T['parameters'] : {
+    query?: Record<string, unknown>;
+};
+/**
+ * Get the type of the bodyOf an endpoint but if it does not have any required keys, then
+ * make it optional
+ */
+type BodyOption<Endpoint> = Endpoint extends {
+    requestBody: {
+        content: {
+            'application/json': any;
+        };
+    };
+} ? HasRequiredKeys<bodyOf<Endpoint>> extends never ? {
+    body?: bodyOf<Endpoint> | undefined;
+} : {
+    body: bodyOf<Endpoint>;
+} : {
+    body?: Record<string, unknown>;
+};
+/**
+ * Combines the body and other parameters into one type, with stuff being optional
+ */
+type MaybeOptionalParams<Params extends Record<HttpMethod, {}>, Location extends keyof Params> = ParamsOption<FilterKeys<Params, Location>> & BodyOption<FilterKeys<Params, Location>>;
+/**
+ * Gets the error statuses of an endpoint
+ */
+type ErrorStatusOf<T> = T extends {
+    responses: Record<number, any>;
+} ? keyof T['responses'] extends number | string ? `${Exclude<keyof T['responses'], OkStatus>}` : string : string;
+/**
+ * An {@link SdkErrorModel} but with narrowed status codes
+ */
+type SdkErrorModelGeneric<T = undefined> = {
+    errors: Array<{
+        detail: string;
+        /** some status code */
+        status: ErrorStatusOf<T>;
+    }>;
+    status: ErrorStatusOf<T>;
+};
+/**
+ * The error model returned from the SDK
+ * Will always contain at least one element!
+ */
+export type SdkErrorModel = {
+    errors: Array<{
+        detail: string;
+        /** some status code */
+        status: string;
+    }>;
+    status: string;
+};
+type EndpointWithResponses = {
+    responses: Record<number, any>;
+};
+type FetchResponse<T, Opts extends requestOptions> = {
+    data: T extends EndpointWithResponses ? ParseAsResponse<SuccessResponse<ResponseObjectMap<T>>, Opts> : unknown;
+    error?: never;
+    response: Response;
+    aborted: false;
+} | {
+    data?: never;
+    error: Expand<T extends EndpointWithResponses ? SdkErrorModelGeneric<T> : unknown>;
+    response: Response;
+    aborted: false;
+} | (keyof Opts extends never ? never : Opts['abortKey'] extends undefined ? never : Opts['abortKey'] extends string | undefined ? {
+    data?: never;
+    error?: never;
+    response?: never;
+    aborted: true;
+} : never);
+export type FetcherArgs = {
+    /** Base url for all fetch requests */
+    url: string;
+    /** Override the fetch function used for requests */
+    fetchFn?: typeof globalThis.fetch;
+    /** Override the fetch function used for auth requests */
+    authFetchFn: typeof globalThis.fetch;
+    /** Used for auth, needed unless ignoreAuth is true */
+    username?: string;
+    /** Used for auth, needed unless ignoreAuth is true */
+    password?: string;
+    /** Do not do the automatic /login requests */
+    ignoreAuth: boolean;
+};
+export declare class Fetcher<Paths extends Record<string, Record<HttpMethod, {}>>> {
+    private opts;
+    private aborts;
+    private accessToken;
+    private expiry;
+    constructor(args: Partial<FetcherArgs>);
+    private doAuth;
+    /** Takes in an abort key to determine what abort signals should be fired and a new signal */
+    private handleAbortKey;
+    /** Transforms an error from the api into an {@link SdkErrorModel} */
+    private parseError;
+    private createFinalURL;
+    /** The actual fetch wrapper. It is type inference blind, beyond the parseAs type */
+    private fetcher;
+    GET<Path extends PathsWithMethod<Paths, 'get'>, Data extends MaybeOptionalParams<Paths[Path], 'get'>, Opts extends requestOptions = {}>(path: Path, data: HasRequiredKeys<Data> extends never ? Data | undefined : Data, opts?: Opts): Promise<FetchResponse<Paths[Path]["get"], Opts>>;
+    PUT<Path extends PathsWithMethod<Paths, 'put'>, Data extends MaybeOptionalParams<Paths[Path], 'put'>, Opts extends requestOptions = {}>(path: Path, data: HasRequiredKeys<Data> extends never ? Data | undefined : Data, opts?: Opts): Promise<FetchResponse<Paths[Path]["put"], Opts>>;
+    POST<Path extends PathsWithMethod<Paths, 'post'>, Data extends MaybeOptionalParams<Paths[Path], 'post'>, Opts extends requestOptions = {}>(path: Path, data: HasRequiredKeys<Data> extends never ? Data | undefined : Data, opts?: Opts): Promise<FetchResponse<Paths[Path]["post"], Opts>>;
+    DELETE<Path extends PathsWithMethod<Paths, 'delete'>, Data extends MaybeOptionalParams<Paths[Path], 'delete'>, Opts extends requestOptions = {}>(path: Path, data: HasRequiredKeys<Data> extends never ? Data | undefined : Data, opts?: Opts): Promise<FetchResponse<Paths[Path]["delete"], Opts>>;
+    OPTIONS<Path extends PathsWithMethod<Paths, 'options'>, Data extends MaybeOptionalParams<Paths[Path], 'options'>, Opts extends requestOptions = {}>(path: Path, data: HasRequiredKeys<Data> extends never ? Data | undefined : Data, opts?: Opts): Promise<FetchResponse<Paths[Path]["options"], Opts>>;
+    HEAD<Path extends PathsWithMethod<Paths, 'head'>, Data extends MaybeOptionalParams<Paths[Path], 'head'>, Opts extends requestOptions = {}>(path: Path, data: HasRequiredKeys<Data> extends never ? Data | undefined : Data, opts?: Opts): Promise<FetchResponse<Paths[Path]["head"], Opts>>;
+}
+export default function createFetcher<Paths extends {}>(...args: ConstructorParameters<typeof Fetcher>): Fetcher<Paths>;
+export {};