@leonardo-ai/sdk 1.1.1

package/dist/internal/utils/requestbody.js

@@ -0,0 +1,266 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeRequestBody = void 0;
+var form_data_1 = __importDefault(require("form-data"));
+var requestMetadataKey = "request";
+var mpFormMetadataKey = "multipart_form";
+function serializeRequestBody(request) {
+    if (!request.hasOwnProperty(requestMetadataKey)) {
+        throw new Error("request body not found");
+    }
+    var requestBodyObj = request;
+    var firstLevelRequestAnn = Reflect.getMetadata(requestMetadataKey, request, requestMetadataKey);
+    if (firstLevelRequestAnn == null)
+        requestBodyObj = request[requestMetadataKey];
+    var fieldNames = Object.getOwnPropertyNames(requestBodyObj);
+    var _a = [{}, {}], requestHeaders = _a[0], requestBody = _a[1];
+    fieldNames.forEach(function (fname) {
+        var _a, _b;
+        var requestAnn = Reflect.getMetadata(requestMetadataKey, requestBodyObj, fname);
+        if (requestAnn == null)
+            return;
+        var requestDecorator = parseRequestDecorator(requestAnn);
+        switch (requestDecorator.MediaType) {
+            case "multipart/form-data":
+            case "multipart/mixed":
+                requestBody = encodeMultipartFormData(requestBodyObj[fname]);
+                requestHeaders = requestBody.getHeaders();
+                break;
+            case "application/x-www-form-urlencoded":
+                _a = [
+                    { "Content-Type": "".concat(requestDecorator.MediaType) },
+                    encodeFormUrlEncodeData(requestBodyObj[fname])
+                ], requestHeaders = _a[0], requestBody = _a[1];
+                break;
+            case "application/json":
+            case "text/json":
+                _b = [
+                    { "Content-Type": "".concat(requestDecorator.MediaType) },
+                    __assign({}, requestBodyObj[fname]),
+                ], requestHeaders = _b[0], requestBody = _b[1];
+                break;
+            default:
+                requestBody = requestBodyObj[fname];
+                var requestBodyType = typeof requestBody;
+                if (requestBodyType === "string" ||
+                    requestBody instanceof String ||
+                    requestBody instanceof Uint8Array)
+                    requestHeaders = { "Content-Type": "".concat(requestDecorator.MediaType) };
+                else
+                    throw new Error("invalid request body type ".concat(requestBodyType, " for mediaType ").concat(requestDecorator.MediaType));
+        }
+    });
+    return [requestHeaders, requestBody];
+}
+exports.serializeRequestBody = serializeRequestBody;
+var encodeFormUrlEncodeData = function (data) {
+    var formData = new form_data_1.default();
+    var fieldNames = Object.getOwnPropertyNames(data);
+    fieldNames.forEach(function (fname) {
+        var _a;
+        var formAnn = Reflect.getMetadata("form", data, fname);
+        if (formAnn === null) {
+            return;
+        }
+        var annotation = parseFormMetadata(formAnn);
+        if (annotation.json) {
+            formData.append((_a = annotation.name) !== null && _a !== void 0 ? _a : fname, JSON.stringify(data[fname]));
+            return;
+        }
+        if (annotation.style === "form") {
+            var parsed_1;
+            if (annotation.explode === true) {
+                parsed_1 = formExplode(fname, data[fname]);
+            }
+            else {
+                parsed_1 = formNotExplode(fname, data[fname]);
+            }
+            Object.keys(parsed_1).forEach(function (key) {
+                parsed_1[key].forEach(function (v) {
+                    return formData.append(key, v);
+                });
+            });
+            return;
+        }
+    });
+    return formData;
+};
+var formExplode = function (fname, data) {
+    var exploded = {};
+    if (Array.isArray(data)) {
+        data.forEach(function (value) {
+            if (!exploded[fname]) {
+                exploded[fname] = [];
+            }
+            exploded[fname].push(value);
+        });
+    }
+    else {
+        if (typeof data === "object") {
+            Object.keys(data).forEach(function (key) {
+                if (!exploded[key]) {
+                    exploded[key] = [];
+                }
+                exploded[key].push(data[key]);
+            });
+        }
+        else {
+            if (!exploded[fname]) {
+                exploded[fname] = [];
+            }
+            exploded[fname].push(data.toString());
+        }
+    }
+    return exploded;
+};
+var formNotExplode = function (fname, data) {
+    var notExploded = {};
+    if (Array.isArray(data)) {
+        if (!notExploded[fname]) {
+            notExploded[fname] = [];
+        }
+        notExploded[fname].push(data
+            .map(function (item) { return item.toString(); })
+            .join(","));
+    }
+    else {
+        if (typeof data === "object") {
+            Object.keys(data).forEach(function (key) {
+                if (!notExploded[key]) {
+                    notExploded[key] = [];
+                }
+                notExploded[fname].push("".concat(key, "=").concat(data[key]));
+            });
+        }
+        else {
+            if (!notExploded[fname]) {
+                notExploded[fname] = [];
+            }
+            notExploded[fname].push(data.toString());
+        }
+    }
+    return notExploded;
+};
+var parseFormMetadata = function (formAnn) {
+    return formAnn.split(";").map(function (keyValue) {
+        var split = keyValue.split("=");
+        if (split.length !== 2) {
+            throw new Error("Unable to parse form metadata \"".concat(keyValue, "\""));
+        }
+        var obj = {};
+        obj[split[0]] = split[0] === "explode" || split[0] === "json" ? split[1] === "true" : split[1];
+        return obj;
+    }).reduce(function (accum, cur) { return (__assign(__assign({}, accum), cur)); });
+};
+function encodeMultipartFormData(form) {
+    var formData = new form_data_1.default();
+    var fieldNames = Object.getOwnPropertyNames(form);
+    fieldNames.forEach(function (fname) {
+        var mpFormAnn = Reflect.getMetadata(mpFormMetadataKey, form, fname);
+        if (mpFormAnn == null)
+            return;
+        var mpFormDecorator = parseMultipartFormDecorator(mpFormAnn);
+        if (mpFormDecorator.File)
+            return encodeMultipartFormDataFile(formData, form[fname]);
+        else if (mpFormDecorator.JSON) {
+            formData.append(mpFormDecorator.Name, JSON.stringify(form[fname]));
+        }
+        else {
+            if (Array.isArray(form[fname])) {
+                form[fname].forEach(function (val) {
+                    formData.append(mpFormDecorator.Name + "[]", String(val));
+                });
+            }
+            else {
+                formData.append(mpFormDecorator.Name, String(form[fname]));
+            }
+        }
+    });
+    return formData;
+}
+function encodeMultipartFormDataFile(formData, file) {
+    if (typeof file !== "object" || Array.isArray(file) || file == null) {
+        throw new Error("invalid type for multipart/form-data file");
+    }
+    var fieldNames = Object.getOwnPropertyNames(file);
+    var content = null;
+    var fileName = "";
+    var mpFormDecoratorName = "";
+    fieldNames.forEach(function (fname) {
+        var mpFormAnn = Reflect.getMetadata(mpFormMetadataKey, file, fname);
+        if (mpFormAnn == null)
+            return;
+        var mpFormDecorator = parseMultipartFormDecorator(mpFormAnn);
+        if (!mpFormDecorator.Content && mpFormDecorator.Name == "")
+            return;
+        if (mpFormDecorator.Content)
+            content = file[fname];
+        else {
+            mpFormDecoratorName = mpFormDecorator.Name;
+            fileName = file[fname];
+        }
+    });
+    if (mpFormDecoratorName === "" || fileName === "" || content == null) {
+        throw new Error("invalid multipart/form-data file");
+    }
+    formData.append("file", Buffer.from(content), fileName);
+    return formData;
+}
+function parseMultipartFormDecorator(mpFormAnn) {
+    // example "name=file"
+    var mpFormDecorator = new MultipartFormDecorator(false, false, false, "");
+    mpFormAnn.split(";").forEach(function (mpFormAnnPart) {
+        var _a = mpFormAnnPart.split("="), mpFormKey = _a[0], mpFormVal = _a[1];
+        switch (mpFormKey) {
+            case "file":
+                mpFormDecorator.File = mpFormVal == "true";
+                break;
+            case "content":
+                mpFormDecorator.Content = mpFormVal == "true";
+                break;
+            case "name":
+                mpFormDecorator.Name = mpFormVal;
+                break;
+            case "json":
+                mpFormDecorator.JSON = mpFormVal == "true";
+        }
+    });
+    return mpFormDecorator;
+}
+var MultipartFormDecorator = /** @class */ (function () {
+    function MultipartFormDecorator(File, Content, JSON, Name) {
+        this.File = File;
+        this.Content = Content;
+        this.JSON = JSON;
+        this.Name = Name;
+    }
+    return MultipartFormDecorator;
+}());
+function parseRequestDecorator(requestAnn) {
+    // example "media_type=multipart/form-data"
+    var requestDecorator = new RequestDecorator("application/octet-stream");
+    var _a = requestAnn.split("="), mediaTypeKey = _a[0], mediaTypeVal = _a[1];
+    if (mediaTypeKey === "media_type")
+        requestDecorator.MediaType = mediaTypeVal;
+    return requestDecorator;
+}
+var RequestDecorator = /** @class */ (function () {
+    function RequestDecorator(MediaType) {
+        this.MediaType = MediaType;
+    }
+    return RequestDecorator;
+}());

package/dist/internal/utils/retries.d.ts

@@ -0,0 +1,20 @@
+import { AxiosResponse } from "axios";
+export declare class BackoffStrategy {
+    initialInterval: number;
+    maxInterval: number;
+    exponent: number;
+    maxElapsedTime: number;
+    constructor(initialInterval: number, maxInterval: number, exponent: number, maxElapsedTime: number);
+}
+export declare class RetryConfig {
+    strategy: string;
+    backoff?: BackoffStrategy;
+    retryConnectionErrors: boolean;
+    constructor(strategy: string, retryConnectionErrors?: boolean);
+}
+export declare class Retries {
+    config: RetryConfig;
+    statusCodes: string[];
+    constructor(config: RetryConfig, statusCodes: string[]);
+}
+export declare function Retry(fn: () => Promise<AxiosResponse<any, any>>, retries: Retries): Promise<AxiosResponse<any, any>>;

package/dist/internal/utils/retries.js

@@ -0,0 +1,223 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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 (g && (g = 0, op[0] && (_ = 0)), _) 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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Retry = exports.Retries = exports.RetryConfig = exports.BackoffStrategy = void 0;
+var axios_1 = require("axios");
+var BackoffStrategy = /** @class */ (function () {
+    function BackoffStrategy(initialInterval, maxInterval, exponent, maxElapsedTime) {
+        this.initialInterval = initialInterval;
+        this.maxInterval = maxInterval;
+        this.exponent = exponent;
+        this.maxElapsedTime = maxElapsedTime;
+    }
+    return BackoffStrategy;
+}());
+exports.BackoffStrategy = BackoffStrategy;
+var RetryConfig = /** @class */ (function () {
+    function RetryConfig(strategy, retryConnectionErrors) {
+        if (retryConnectionErrors === void 0) { retryConnectionErrors = true; }
+        this.strategy = strategy;
+        this.retryConnectionErrors = retryConnectionErrors;
+    }
+    return RetryConfig;
+}());
+exports.RetryConfig = RetryConfig;
+var Retries = /** @class */ (function () {
+    function Retries(config, statusCodes) {
+        this.config = config;
+        this.statusCodes = statusCodes;
+    }
+    return Retries;
+}());
+exports.Retries = Retries;
+var PermanentError = /** @class */ (function (_super) {
+    __extends(PermanentError, _super);
+    function PermanentError(inner) {
+        var _this = _super.call(this, "Permanent error") || this;
+        _this.inner = inner;
+        return _this;
+    }
+    return PermanentError;
+}(Error));
+var TemporaryError = /** @class */ (function (_super) {
+    __extends(TemporaryError, _super);
+    function TemporaryError(res) {
+        var _this = _super.call(this, "Temporary error") || this;
+        _this.res = res;
+        return _this;
+    }
+    return TemporaryError;
+}(Error));
+function Retry(fn, retries) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    return __awaiter(this, void 0, void 0, function () {
+        var _j;
+        var _this = this;
+        return __generator(this, function (_k) {
+            switch (_k.label) {
+                case 0:
+                    _j = retries.config.strategy;
+                    switch (_j) {
+                        case "backoff": return [3 /*break*/, 1];
+                    }
+                    return [3 /*break*/, 2];
+                case 1: return [2 /*return*/, retryBackoff(function () { return __awaiter(_this, void 0, void 0, function () {
+                        var res, err_1;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    _a.trys.push([0, 2, , 3]);
+                                    return [4 /*yield*/, fn()];
+                                case 1:
+                                    res = _a.sent();
+                                    if (isRetryableResponse(res, retries.statusCodes)) {
+                                        throw new TemporaryError(res);
+                                    }
+                                    return [2 /*return*/, res];
+                                case 2:
+                                    err_1 = _a.sent();
+                                    if (err_1 instanceof axios_1.AxiosError) {
+                                        if (err_1.response) {
+                                            if (isRetryableResponse(err_1.response, retries.statusCodes)) {
+                                                throw err_1;
+                                            }
+                                            throw new PermanentError(err_1);
+                                        }
+                                        else if (err_1.request) {
+                                            throw err_1;
+                                        }
+                                        else {
+                                            throw new PermanentError(err_1);
+                                        }
+                                    }
+                                    else if (err_1 instanceof TemporaryError) {
+                                        throw err_1;
+                                    }
+                                    throw new PermanentError(err_1);
+                                case 3: return [2 /*return*/];
+                            }
+                        });
+                    }); }, (_b = (_a = retries.config.backoff) === null || _a === void 0 ? void 0 : _a.initialInterval) !== null && _b !== void 0 ? _b : 500, (_d = (_c = retries.config.backoff) === null || _c === void 0 ? void 0 : _c.maxInterval) !== null && _d !== void 0 ? _d : 60000, (_f = (_e = retries.config.backoff) === null || _e === void 0 ? void 0 : _e.exponent) !== null && _f !== void 0 ? _f : 1.5, (_h = (_g = retries.config.backoff) === null || _g === void 0 ? void 0 : _g.maxElapsedTime) !== null && _h !== void 0 ? _h : 3600000)];
+                case 2: return [4 /*yield*/, fn()];
+                case 3: return [2 /*return*/, _k.sent()];
+            }
+        });
+    });
+}
+exports.Retry = Retry;
+function isRetryableResponse(res, statusCodes) {
+    for (var _i = 0, statusCodes_1 = statusCodes; _i < statusCodes_1.length; _i++) {
+        var code = statusCodes_1[_i];
+        if (code.toUpperCase().includes("X")) {
+            var codeRange = parseInt(code[0]);
+            if (isNaN(codeRange)) {
+                throw new Error("Invalid status code range");
+            }
+            var s = res.status / 100;
+            if (s >= codeRange && s < codeRange + 1) {
+                return true;
+            }
+        }
+        else if (res.status == parseInt(code)) {
+            return true;
+        }
+    }
+    return false;
+}
+function retryBackoff(fn, initialInterval, maxInterval, exponent, maxElapsedTime) {
+    return __awaiter(this, void 0, void 0, function () {
+        var start, x, err_2, now, d;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    start = Date.now();
+                    x = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!true) return [3 /*break*/, 7];
+                    _a.label = 2;
+                case 2:
+                    _a.trys.push([2, 4, , 6]);
+                    return [4 /*yield*/, fn()];
+                case 3: return [2 /*return*/, _a.sent()];
+                case 4:
+                    err_2 = _a.sent();
+                    if (err_2 instanceof PermanentError) {
+                        throw err_2.inner;
+                    }
+                    now = Date.now();
+                    if (now - start > maxElapsedTime) {
+                        if (err_2 instanceof TemporaryError) {
+                            return [2 /*return*/, err_2.res];
+                        }
+                        throw err_2;
+                    }
+                    d = Math.min(initialInterval * Math.pow(x, exponent) + Math.random() * 1000, maxInterval);
+                    return [4 /*yield*/, delay(d)];
+                case 5:
+                    _a.sent();
+                    x++;
+                    return [3 /*break*/, 6];
+                case 6: return [3 /*break*/, 1];
+                case 7: return [2 /*return*/];
+            }
+        });
+    });
+}
+function delay(delay) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, new Promise(function (resolve) { return setTimeout(resolve, delay); })];
+        });
+    });
+}

package/dist/internal/utils/security.d.ts

@@ -0,0 +1,2 @@
+import { AxiosInstance } from "axios";
+export declare function createSecurityClient(client: AxiosInstance, security: any): AxiosInstance;

package/dist/internal/utils/security.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSecurityClient = void 0;
+var securityMetadataKey = "security";
+function createSecurityClient(client, security) {
+    return parseSecurityClass(client, security);
+}
+exports.createSecurityClient = createSecurityClient;
+function parseSecurityDecorator(securityAnn) {
+    // scheme=true;type=apiKey;subtype=header"
+    var option = false;
+    var scheme = false;
+    var name = "";
+    var securityType = "";
+    var securitySubType = "";
+    securityAnn.split(";").forEach(function (securityAnnPart) {
+        var _a = securityAnnPart.split("="), sKey = _a[0], sVal = _a[1];
+        switch (sKey) {
+            case "name":
+                name = sVal;
+                break;
+            case "type":
+                securityType = sVal;
+                break;
+            case "subtype":
+                securitySubType = sVal;
+                break;
+            case "option":
+                option = sVal == "true";
+                break;
+            case "scheme":
+                scheme = sVal == "true";
+        }
+    });
+    return new SecurityDecorator(name, securityType, option, scheme, securitySubType);
+}
+function parseSecurityClass(client, security) {
+    var fieldNames = Object.getOwnPropertyNames(security);
+    fieldNames.forEach(function (fname) {
+        var securityAnn = Reflect.getMetadata(securityMetadataKey, security, fname);
+        if (securityAnn == null)
+            return;
+        var securityDecorator = parseSecurityDecorator(securityAnn);
+        if (securityDecorator == null)
+            return;
+        if (securityDecorator.Option) {
+            return parseSecurityOption(client, security[fname]);
+        }
+        else if (securityDecorator.Scheme) {
+            return parseSecurityScheme(client, securityDecorator, security[fname]);
+        }
+    });
+    return client;
+}
+function parseSecurityOption(client, optionType) {
+    var fieldNames = Object.getOwnPropertyNames(optionType);
+    fieldNames.forEach(function (fname) {
+        var securityAnn = Reflect.getMetadata(securityMetadataKey, optionType, fname);
+        if (securityAnn == null)
+            return;
+        var securityDecorator = parseSecurityDecorator(securityAnn);
+        if (securityDecorator != null && securityDecorator.Scheme)
+            return;
+        if (securityDecorator.Scheme) {
+            return parseSecurityScheme(client, securityDecorator, optionType[fname]);
+        }
+    });
+    return client;
+}
+function parseSecurityScheme(client, schemeDecorator, scheme) {
+    if (schemeDecorator.Type === "http" && schemeDecorator.SubType === "basic") {
+        return parseBasicAuthScheme(client, scheme);
+    }
+    var fieldNames = Object.getOwnPropertyNames(scheme);
+    fieldNames.forEach(function (fname) {
+        var securityAnn = Reflect.getMetadata(securityMetadataKey, scheme, fname);
+        if (securityAnn == null)
+            return;
+        var securityDecorator = parseSecurityDecorator(securityAnn);
+        if (securityDecorator == null || securityDecorator.Name === "")
+            return;
+        switch (schemeDecorator.Type) {
+            case "apiKey":
+                switch (schemeDecorator.SubType) {
+                    case "header":
+                        client.defaults.headers.common[securityDecorator.Name] =
+                            scheme[fname];
+                        break;
+                    case "query":
+                        client.defaults.params[securityDecorator.Name] = scheme[fname];
+                        break;
+                    case "cookie":
+                        var securityDecoratorName = securityDecorator.Name;
+                        var val = scheme[fname];
+                        client.defaults.headers.common["Cookie"] = "".concat(securityDecoratorName, "=").concat(val);
+                        break;
+                    default:
+                        throw new Error("not supported");
+                }
+                break;
+            case "openIdConnect":
+                client.defaults.headers.common[securityDecorator.Name] = scheme[fname];
+                break;
+            case "oauth2":
+                client.defaults.headers.common[securityDecorator.Name] = scheme[fname];
+                break;
+            case "http":
+                switch (schemeDecorator.SubType) {
+                    case "basic":
+                        break;
+                    case "bearer":
+                        client.defaults.headers.common[securityDecorator.Name] =
+                            scheme[fname];
+                        break;
+                    default:
+                        throw new Error("not supported");
+                }
+                break;
+            default:
+                throw new Error("not supported");
+        }
+    });
+    return client;
+}
+function parseBasicAuthScheme(client, scheme) {
+    var username, password = "";
+    var fieldNames = Object.getOwnPropertyNames(scheme);
+    fieldNames.forEach(function (fname) {
+        var securityAnn = Reflect.getMetadata(securityMetadataKey, scheme, fname);
+        if (securityAnn == null)
+            return;
+        var securityDecorator = parseSecurityDecorator(securityAnn);
+        if (securityDecorator == null || securityDecorator.Name === "")
+            return;
+        switch (securityDecorator.Name) {
+            case "username":
+                username = scheme[fname];
+                break;
+            case "password":
+                password = scheme[fname];
+                break;
+        }
+    });
+    client.defaults.headers.common["Authorization"] = "Basic ".concat(Buffer.from("".concat(username, ":").concat(password)).toString("base64"));
+    return client;
+}
+var SecurityDecorator = /** @class */ (function () {
+    function SecurityDecorator(Name, Type, Option, Scheme, SubType) {
+        this.Name = Name;
+        this.Type = Type;
+        this.Option = Option;
+        this.Scheme = Scheme;
+        this.SubType = SubType;
+    }
+    return SecurityDecorator;
+}());

package/dist/internal/utils/utils.d.ts

@@ -0,0 +1,19 @@
+import "reflect-metadata";
+import { ParamDecorator } from "./pathparams";
+export declare class SpeakeasyBase {
+    constructor(payload?: Record<string | symbol, unknown>);
+}
+export declare function SpeakeasyMetadata<T extends SpeakeasyBase = Record<string | symbol, unknown>>(params?: {
+    data?: string;
+    elemType?: {
+        new (): T;
+    };
+    elemDepth?: number;
+}): PropertyDecorator;
+export declare function replaceParameters(stringWithParams: string, params: Map<string, string>): string;
+export declare function generateURL(serverURL: string, path: string, pathParams: any): string;
+export declare function parseParamDecorator(ann: string, fName: string, defaultStyle: string, defaultExplode: boolean): ParamDecorator;
+export declare function isStringRecord(obj: any): obj is Record<string, string>;
+export declare function isNumberRecord(obj: any): obj is Record<string, number>;
+export declare function isBooleanRecord(obj: any): obj is Record<string, boolean>;
+export declare function isEmpty(value: any): boolean;