@resolution/jira-api-client 0.4.6 → 0.5.0

package/lib/openapi/serviceManagement/BaseJiraServiceManagementApiClient.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseJiraServiceManagementApiClient = exports.BaseJiraServiceManagementApiClientError = void 0;
+// DO NOT EDIT!
+// This file is generated by "api-typescript-generator".
+// To update this file run "yarn build:openapi".
+const commonHttpClient = require("./core/CommonHttpClient");
+const CommonHttpService_1 = require("./core/CommonHttpService");
+const AssetsService_1 = require("./services/AssetsService");
+const CustomerService_1 = require("./services/CustomerService");
+const InfoService_1 = require("./services/InfoService");
+const KnowledgebaseService_1 = require("./services/KnowledgebaseService");
+const OrganizationService_1 = require("./services/OrganizationService");
+const RequestService_1 = require("./services/RequestService");
+const RequesttypeService_1 = require("./services/RequesttypeService");
+const ServicedeskService_1 = require("./services/ServicedeskService");
+const validationSchemaStorage_1 = require("./validationSchemaStorage");
+class BaseJiraServiceManagementApiClientError extends commonHttpClient.CommonHttpClientError {
+    constructor() {
+        super(...arguments);
+        this.name = "BaseJiraServiceManagementApiClientError";
+    }
+}
+exports.BaseJiraServiceManagementApiClientError = BaseJiraServiceManagementApiClientError;
+/**
+ * Service Management Public REST API
+ *
+ * Public REST API for Jira Service Management
+ *
+ * @version 1001.0.0-SNAPSHOT-7a4eaa71561009e58ded1503889be69ca87a407d
+ */
+class BaseJiraServiceManagementApiClient extends CommonHttpService_1.CommonHttpService {
+    /** @see https://developer.atlassian.com/cloud/jira/service-desk/rest/api-group-assets */
+    get assets() {
+        return this.getServiceInstance(AssetsService_1.AssetsService);
+    }
+    /** @see https://developer.atlassian.com/cloud/jira/service-desk/rest/api-group-customer */
+    get customer() {
+        return this.getServiceInstance(CustomerService_1.CustomerService);
+    }
+    /** @see https://developer.atlassian.com/cloud/jira/service-desk/rest/api-group-info */
+    get info() {
+        return this.getServiceInstance(InfoService_1.InfoService);
+    }
+    /** @see https://developer.atlassian.com/cloud/jira/service-desk/rest/api-group-knowledgebase */
+    get knowledgebase() {
+        return this.getServiceInstance(KnowledgebaseService_1.KnowledgebaseService);
+    }
+    /** @see https://developer.atlassian.com/cloud/jira/service-desk/rest/api-group-organization */
+    get organization() {
+        return this.getServiceInstance(OrganizationService_1.OrganizationService);
+    }
+    /** @see https://developer.atlassian.com/cloud/jira/service-desk/rest/api-group-request */
+    get request() {
+        return this.getServiceInstance(RequestService_1.RequestService);
+    }
+    /** @see https://developer.atlassian.com/cloud/jira/service-desk/rest/api-group-requesttype */
+    get requesttype() {
+        return this.getServiceInstance(RequesttypeService_1.RequesttypeService);
+    }
+    /** @see https://developer.atlassian.com/cloud/jira/service-desk/rest/api-group-servicedesk */
+    get servicedesk() {
+        return this.getServiceInstance(ServicedeskService_1.ServicedeskService);
+    }
+    constructor(options) {
+        super(() => this.client);
+        this.client = new commonHttpClient.CommonHttpClient({
+            baseUrl: "https://your-domain.atlassian.net",
+            binaryResponseType: "blob",
+            errorClass: BaseJiraServiceManagementApiClientError,
+        });
+        this.getClient = () => this.client;
+        this.client.setOptions(Object.assign(Object.assign({}, this.client.getOptions()), options));
+    }
+}
+exports.BaseJiraServiceManagementApiClient = BaseJiraServiceManagementApiClient;
+validationSchemaStorage_1.validationSchemaStorage.setErrorClass(BaseJiraServiceManagementApiClientError);
+//# sourceMappingURL=BaseJiraServiceManagementApiClient.js.map

package/lib/openapi/serviceManagement/BaseJiraServiceManagementApiClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseJiraServiceManagementApiClient.js","sourceRoot":"","sources":["../../../src/openapi/serviceManagement/BaseJiraServiceManagementApiClient.ts"],"names":[],"mappings":";;;AAAA,eAAe;AACf,wDAAwD;AACxD,gDAAgD;AAChD,4DAA4D;AAC5D,gEAA6D;AAI7D,4DAAyD;AACzD,gEAA6D;AAC7D,wDAAqD;AACrD,0EAAuE;AACvE,wEAAqE;AACrE,8DAA2D;AAC3D,sEAAmE;AACnE,sEAAmE;AACnE,uEAAoE;AAGpE,MAAa,uCAAwC,SAAQ,gBAAgB,CAAC,qBAAqB;IAAnG;;QACE,SAAI,GAAG,yCAAyC,CAAC;IACnD,CAAC;CAAA;AAFD,0FAEC;AACD;;;;;;GAMG;AACH,MAAa,kCAAmC,SAAQ,qCAAiB;IAOvE,yFAAyF;IACzF,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,kBAAkB,CAAC,6BAAa,CAAC,CAAC;IAChD,CAAC;IACD,2FAA2F;IAC3F,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,kBAAkB,CAAC,iCAAe,CAAC,CAAC;IAClD,CAAC;IACD,uFAAuF;IACvF,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,kBAAkB,CAAC,yBAAW,CAAC,CAAC;IAC9C,CAAC;IACD,gGAAgG;IAChG,IAAI,aAAa;QACf,OAAO,IAAI,CAAC,kBAAkB,CAAC,2CAAoB,CAAC,CAAC;IACvD,CAAC;IACD,+FAA+F;IAC/F,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,kBAAkB,CAAC,yCAAmB,CAAC,CAAC;IACtD,CAAC;IACD,0FAA0F;IAC1F,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,kBAAkB,CAAC,+BAAc,CAAC,CAAC;IACjD,CAAC;IACD,8FAA8F;IAC9F,IAAI,WAAW;QACb,OAAO,IAAI,CAAC,kBAAkB,CAAC,uCAAkB,CAAC,CAAC;IACrD,CAAC;IACD,8FAA8F;IAC9F,IAAI,WAAW;QACb,OAAO,IAAI,CAAC,kBAAkB,CAAC,uCAAkB,CAAC,CAAC;IACrD,CAAC;IACD,YAAY,OAAmD;QAC7D,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAvC3B,WAAM,GAAG,IAAI,gBAAgB,CAAC,gBAAgB,CAAC;YAC7C,OAAO,EAAE,mCAAmC;YAC5C,kBAAkB,EAAE,MAAM;YAC1B,UAAU,EAAE,uCAAuC;SACpD,CAAC,CAAC;QACH,cAAS,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC;QAmC5B,IAAI,CAAC,MAAM,CAAC,UAAU,iCACjB,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,GACxB,OAAO,EACV,CAAC;IACL,CAAC;CACF;AA9CD,gFA8CC;AACD,iDAAuB,CAAC,aAAa,CAAC,uCAAuC,CAAC,CAAC"}

package/lib/openapi/serviceManagement/core/CommonHttpClient.d.ts

@@ -0,0 +1,196 @@
+export interface CommonHttpClientOptions {
+    baseUrl: string;
+    errorClass: {
+        new (url: URL, request: CommonHttpClientFetchRequest | undefined, response: CommonHttpClientFetchResponse | undefined, options: CommonHttpClientOptions | undefined, message: string): Error;
+    };
+    headers?: CommonHttpClientRequestHeaders;
+    preprocessRequest?: (request: CommonHttpClientRequest) => Promise<CommonHttpClientRequest>;
+    preprocessFetchResponse?: (response: CommonHttpClientFetchResponse, request: CommonHttpClientFetchRequest) => Promise<CommonHttpClientFetchResponse>;
+    fetch?: (url: URL, request: CommonHttpClientFetchRequest) => Promise<CommonHttpClientFetchResponse>;
+    binaryResponseType: "blob" | "readableStream";
+    formatHttpErrorMessage?: (response: CommonHttpClientFetchResponse, request: CommonHttpClientFetchRequest) => string;
+}
+export interface CommonHttpClientRequestHeaders {
+    [headerName: string]: string | undefined | null;
+}
+export interface CommonHttpClientFetchRequestHeaders {
+    [headerName: string]: string;
+}
+/**
+ * Request prepared for the fetch function.
+ */
+export interface CommonHttpClientFetchRequest {
+    /**
+     * HTTP Method.
+     */
+    method: "GET" | "HEAD" | "POST" | "PUT" | "DELETE" | "CONNECT" | "OPTIONS" | "PATCH";
+    /**
+     * Request headers.
+     */
+    headers: CommonHttpClientFetchRequestHeaders;
+    /**
+     * Request body.
+     */
+    body?: BodyInit;
+    /**
+     * Cache mode.
+     */
+    cache: "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload";
+    /**
+     * Credentials mode.
+     */
+    credentials: "include" | "omit" | "same-origin";
+    /**
+     * Redirect mode.
+     */
+    redirect: "error" | "follow" | "manual";
+    /**
+     * Custom request properties. Can be used to pass metadata to the fetch function.
+     */
+    customRequestProps?: Record<string, unknown>;
+}
+/**
+ * Request in terms of OpenAPI.
+ */
+export type CommonHttpClientRequest = Omit<CommonHttpClientFetchRequest, "body" | "headers" | "cache" | "credentials" | "redirect"> & {
+    /**
+     * Path to the resource.
+     */
+    path: string;
+    /**
+     * Path parameters, i.e. {id}.
+     */
+    pathParams?: Record<string, unknown>;
+    /**
+     * Query parameters.
+     */
+    query?: Record<string, unknown>;
+    /**
+     * Request body.
+     */
+    body?: unknown;
+    /**
+     * Request headers.
+     */
+    headers?: CommonHttpClientRequestHeaders;
+} & Partial<Pick<CommonHttpClientFetchRequest, "cache" | "credentials" | "redirect">>;
+/**
+ * Response of the fetch function.
+ */
+export interface CommonHttpClientFetchResponse {
+    /**
+     * HTTP status code.
+     */
+    status: number;
+    /**
+     * HTTP status code explanation.
+     */
+    statusText: string;
+    /**
+     * Response body.
+     */
+    body: CommonHttpClientFetchResponseBody;
+    /**
+     * Whether the request was successful. True for 2xx status codes.
+     */
+    ok: boolean;
+    /**
+     * The final URL of the request (after redirects).
+     */
+    url: string;
+    /**
+     * Response headers.
+     */
+    headers: CommonHttpClientResponseHeaders;
+    /**
+     * Custom request properties. Can be used to pass metadata outside the fetch function.
+     */
+    customRequestProps?: Record<string, unknown>;
+}
+export type CommonHttpClientResponseHeaders = Record<string, string> & {
+    "set-cookie"?: string[];
+};
+export type CommonHttpClientFetchResponseBody = {
+    type: "json";
+    data: unknown;
+} | {
+    type: "blob";
+    data: Blob;
+} | {
+    type: "readableStream";
+    data: ReadableStream<Uint8Array>;
+};
+export interface CommonHttpClientResponse<T> {
+    status: number;
+    mediaType?: string;
+    body: T;
+    response: CommonHttpClientFetchResponse;
+}
+export declare class CommonHttpClientError extends Error {
+    readonly url: URL;
+    readonly request: CommonHttpClientFetchRequest | undefined;
+    readonly response: CommonHttpClientFetchResponse | undefined;
+    readonly options: CommonHttpClientOptions | undefined;
+    constructor(url: URL, request: CommonHttpClientFetchRequest | undefined, response: CommonHttpClientFetchResponse | undefined, options: CommonHttpClientOptions | undefined, message: string);
+}
+/**
+ * `extends unknown` is a trick to split the union into individual types.
+ */
+type ResponseByMediaType<T extends CommonHttpClientResponse<unknown>, K extends string> = T extends unknown ? ((a: T) => void) extends (a: {
+    mediaType: K;
+    status: infer _Status;
+    body: infer _Body;
+    response: CommonHttpClientFetchResponse;
+}) => void ? T : never : never;
+export declare function checkReponseMediaType<T extends CommonHttpClientResponse<unknown>, K extends string>(response: T, mediaType: K): response is ResponseByMediaType<T, K> extends never ? ResponseByMediaType<T, "*/*"> : ResponseByMediaType<T, K>;
+export declare function isJsonMediaType(mediaType: string): boolean;
+type AsCreatedResponseFunction<KCreated extends string, KOther extends string> = <T extends CommonHttpClientResponse<unknown>>(response: T) => ({
+    [K in KCreated]: Extract<T, {
+        status: 201;
+    }>["body"];
+} & {
+    created: true;
+}) | ({
+    [K in KOther]: Extract<T, {
+        status: 200;
+    }>["body"];
+} & {
+    created: false;
+});
+export declare function asCreatedResponse<KCreated extends string>(keyCreated: KCreated): AsCreatedResponseFunction<KCreated, KCreated>;
+export declare function asCreatedResponse<KCreated extends string, KOther extends string>(keyCreated: KCreated, keyOther: KOther): AsCreatedResponseFunction<KCreated, KOther>;
+export declare const getBody: <T>({ body }: CommonHttpClientResponse<T>) => T;
+export declare const castResponse: <T extends Omit<CommonHttpClientResponse<unknown>, "response">>() => (response: CommonHttpClientResponse<unknown>) => WithResponse<T>;
+export declare const discardResult: () => void;
+export type WithResponse<T> = T & {
+    response: CommonHttpClientFetchResponse;
+};
+export declare function createClientWithServices<TOptions, TClient extends {
+    getClient(): CommonHttpClient;
+}, TServices extends Record<string, {
+    new (client: CommonHttpClient): unknown;
+}>>(this: {
+    new (options?: TOptions): TClient;
+}, services: TServices, options?: TOptions): TClient & {
+    [K in keyof TServices as K extends string ? Uncapitalize<K extends `${infer TName}Service` ? TName : K> : K]: InstanceType<TServices[K]>;
+};
+export declare class CommonHttpClient {
+    protected options: CommonHttpClientOptions;
+    constructor(options: CommonHttpClientOptions);
+    setOptions(options: CommonHttpClientOptions): void;
+    getOptions(): CommonHttpClientOptions;
+    protected getSearchParams(params: Record<string, unknown>): URLSearchParams;
+    protected buildUrlPath(request: CommonHttpClientRequest): string;
+    protected buildUrl(request: CommonHttpClientRequest): URL;
+    protected fetch(url: URL, request: CommonHttpClientFetchRequest): Promise<CommonHttpClientFetchResponse>;
+    request(request: CommonHttpClientRequest): Promise<CommonHttpClientFetchResponse>;
+    responseHandler(distribution: {
+        [statusCode: string]: {
+            [mediaType: string]: CommonHttpClientFetchResponseBody["type"];
+        };
+    }): (response: CommonHttpClientFetchResponse) => Promise<CommonHttpClientResponse<unknown>>;
+    private cleanupHeaders;
+    protected getRequestBody(request: CommonHttpClientRequest): BodyInit | undefined;
+    protected preprocessRequest(request: CommonHttpClientRequest): Promise<CommonHttpClientRequest>;
+}
+export {};

package/lib/openapi/serviceManagement/core/CommonHttpClient.js

@@ -0,0 +1,390 @@
+"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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonHttpClient = exports.createClientWithServices = exports.discardResult = exports.castResponse = exports.getBody = exports.asCreatedResponse = exports.isJsonMediaType = exports.checkReponseMediaType = exports.CommonHttpClientError = void 0;
+class CommonHttpClientError extends Error {
+    constructor(url, request, response, options, message) {
+        super(message);
+        this.name = "OpenApiClientError";
+        this.url = url;
+        this.request = request;
+        this.response = response;
+        this.options = options;
+    }
+}
+exports.CommonHttpClientError = CommonHttpClientError;
+const jsonContentTypeRegExp = /^application\/(\w+\+)?json/;
+function readableStreamToBlob(stream) {
+    const chunks = [];
+    const reader = stream.getReader();
+    return new Promise((resolve, reject) => {
+        reader.read().then(function process({ done, value }) {
+            if (value) {
+                chunks.push(value);
+            }
+            if (done) {
+                resolve(new Blob(chunks));
+                return;
+            }
+            reader.read().then(process, reject);
+        }, reject);
+    });
+}
+function convertResponseBody(body, destType) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (body.type === destType) {
+            return body;
+        }
+        if (body.type === "json") {
+            const blob = new Blob([JSON.stringify(body.data)]);
+            if (destType === "blob") {
+                return {
+                    type: "blob",
+                    data: blob,
+                };
+            }
+            else if (destType === "readableStream") {
+                return {
+                    type: "readableStream",
+                    data: blob.stream(),
+                };
+            }
+            else {
+                throw new Error("Invalid destination type.");
+            }
+        }
+        if (body.type === "blob") {
+            if (destType === "json") {
+                return {
+                    type: "json",
+                    data: JSON.parse(yield body.data.text()),
+                };
+            }
+            else if (destType === "readableStream") {
+                return {
+                    type: "readableStream",
+                    data: body.data.stream(),
+                };
+            }
+            else {
+                throw new Error("Invalid destination type.");
+            }
+        }
+        if (body.type === "readableStream") {
+            if (destType === "json") {
+                return {
+                    type: "json",
+                    data: JSON.parse(yield (yield readableStreamToBlob(body.data)).text()),
+                };
+            }
+            else if (destType === "blob") {
+                return {
+                    type: "blob",
+                    data: yield readableStreamToBlob(body.data),
+                };
+            }
+            else {
+                throw new Error("Invalid destination type.");
+            }
+        }
+        throw new Error("Invalid response body type.");
+    });
+}
+function checkReponseMediaType(response, mediaType) {
+    return response.mediaType === mediaType;
+}
+exports.checkReponseMediaType = checkReponseMediaType;
+function isJsonMediaType(mediaType) {
+    return Boolean(mediaType.match(jsonContentTypeRegExp));
+}
+exports.isJsonMediaType = isJsonMediaType;
+function asCreatedResponse(...keys) {
+    var _a;
+    const keyCreated = keys[0];
+    const keyOther = (_a = keys[1]) !== null && _a !== void 0 ? _a : keyCreated;
+    return (response) => {
+        if (response.status === 201) {
+            return {
+                created: true,
+                [keyCreated]: response.body,
+            };
+        }
+        else {
+            return {
+                created: false,
+                [keyOther]: response.body,
+            };
+        }
+    };
+}
+exports.asCreatedResponse = asCreatedResponse;
+const getBody = ({ body }) => body;
+exports.getBody = getBody;
+const castResponse = () => (response) => response;
+exports.castResponse = castResponse;
+const discardResult = () => { };
+exports.discardResult = discardResult;
+function createClientWithServices(services, options) {
+    const client = new this(options);
+    const extension = {};
+    for (const serviceName in services) {
+        if (Object.prototype.hasOwnProperty.call(services, serviceName)) {
+            extension[serviceName
+                .replace(/[^\b]Service$/, "")
+                .replace(/^\w/, (s) => s.toLowerCase())] = new services[serviceName](client.getClient());
+        }
+    }
+    return Object.assign(client, extension);
+}
+exports.createClientWithServices = createClientWithServices;
+function getErrorMessage(e) {
+    return e instanceof Error ? e.message : String(e);
+}
+class CommonHttpClient {
+    constructor(options) {
+        this.options = options;
+    }
+    setOptions(options) {
+        this.options = options;
+    }
+    getOptions() {
+        return this.options;
+    }
+    getSearchParams(params) {
+        const result = new URLSearchParams();
+        const process = (key, value) => {
+            if (value !== undefined && value !== null) {
+                if (Array.isArray(value)) {
+                    for (const arrayVal of value) {
+                        process(key, arrayVal);
+                    }
+                }
+                else if (typeof value === "object") {
+                    for (const [subKey, subValue] of Object.entries(params)) {
+                        process(`${key}[${subKey}]`, subValue);
+                    }
+                }
+                else {
+                    result.append(key, String(value));
+                }
+            }
+        };
+        for (const [key, value] of Object.entries(params)) {
+            process(key, value);
+        }
+        return result;
+    }
+    buildUrlPath(request) {
+        const pathParams = request.pathParams;
+        if (pathParams) {
+            return request.path.replace(/\{(.*?)}/g, (original, paramName) => {
+                if (Object.prototype.hasOwnProperty.call(pathParams, paramName)) {
+                    return encodeURI(String(pathParams[paramName]));
+                }
+                return original;
+            });
+        }
+        return request.path;
+    }
+    buildUrl(request) {
+        const url = new URL(this.buildUrlPath(request).replace(/^\//, ""), this.options.baseUrl.replace(/\/?$/, "/"));
+        if (request.query) {
+            for (const [key, value] of this.getSearchParams(request.query)) {
+                url.searchParams.append(key, value);
+            }
+        }
+        return url;
+    }
+    fetch(url, request) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestProps = __rest(request, []);
+            const requestInit = requestProps;
+            const response = yield fetch(url, requestInit);
+            const body = isJsonMediaType((_a = response.headers.get("content-type")) !== null && _a !== void 0 ? _a : "")
+                ? {
+                    type: "json",
+                    data: yield response.json(),
+                }
+                : {
+                    type: "blob",
+                    data: yield response.blob(),
+                };
+            const headers = {};
+            response.headers.forEach((value, key) => {
+                headers[key] = value;
+            });
+            if (response.headers.has("set-cookie") &&
+                "getSetCookie" in response.headers) {
+                headers["set-cookie"] = response.headers.getSetCookie();
+            }
+            return {
+                status: response.status,
+                statusText: response.statusText,
+                body,
+                url: response.url,
+                headers,
+                ok: response.ok,
+                customRequestProps: request.customRequestProps,
+            };
+        });
+    }
+    request(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                request = yield this.preprocessRequest(request);
+            }
+            catch (e) {
+                let url;
+                try {
+                    url = this.buildUrl(request);
+                }
+                catch (e) {
+                    throw new this.options.errorClass(new URL(request.path, this.options.baseUrl), undefined, undefined, this.options, `Error building request URL: ${getErrorMessage(e)}`);
+                }
+                throw new this.options.errorClass(url, undefined, undefined, this.options, `preprocessRequest error: ${getErrorMessage(e)}`);
+            }
+            let url;
+            try {
+                url = this.buildUrl(request);
+            }
+            catch (e) {
+                throw new this.options.errorClass(new URL(request.path, this.options.baseUrl), undefined, undefined, this.options, `Error building request URL: ${getErrorMessage(e)}`);
+            }
+            const { body, path: _path, pathParams: _pathParams, query: _query, headers: requestHeaders, cache, credentials, redirect } = request, otherRequestProps = __rest(request, ["body", "path", "pathParams", "query", "headers", "cache", "credentials", "redirect"]);
+            const headers = this.cleanupHeaders(requestHeaders);
+            const fetchRequest = Object.assign(Object.assign({}, otherRequestProps), { headers, cache: cache !== null && cache !== void 0 ? cache : "default", credentials: credentials !== null && credentials !== void 0 ? credentials : "same-origin", redirect: redirect !== null && redirect !== void 0 ? redirect : "follow", body: this.getRequestBody(request) });
+            let fetchResponse;
+            try {
+                if (this.options.fetch) {
+                    fetchResponse = yield this.options.fetch(url, fetchRequest);
+                }
+                else {
+                    fetchResponse = yield this.fetch(url, fetchRequest);
+                }
+            }
+            catch (e) {
+                throw new this.options.errorClass(url, fetchRequest, undefined, this.options, getErrorMessage(e));
+            }
+            if (this.options.preprocessFetchResponse) {
+                try {
+                    fetchResponse = yield this.options.preprocessFetchResponse(fetchResponse, fetchRequest);
+                }
+                catch (e) {
+                    throw new this.options.errorClass(url, fetchRequest, fetchResponse, this.options, `preprocessFetchResponse error: ${getErrorMessage(e)}`);
+                }
+            }
+            if (!fetchResponse.ok) {
+                throw new this.options.errorClass(url, fetchRequest, fetchResponse, this.options, this.options.formatHttpErrorMessage
+                    ? this.options.formatHttpErrorMessage(fetchResponse, fetchRequest)
+                    : `HTTP Error ${fetchResponse.status} (${fetchResponse.statusText})`);
+            }
+            return fetchResponse;
+        });
+    }
+    responseHandler(distribution) {
+        return (response) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const body = response.body;
+            const contentType = response.headers["content-type"];
+            const mediaType = contentType
+                ? contentType.replace(/;.*$/, "")
+                : undefined;
+            const mediaTypes = (_a = distribution[response.status]) !== null && _a !== void 0 ? _a : {};
+            let destType;
+            if (mediaType) {
+                destType = mediaTypes[mediaType];
+                if (!destType) {
+                    destType = mediaTypes[mediaType.replace(/\/.*$/, "/*")];
+                }
+                if (!destType) {
+                    destType = mediaTypes[mediaType.replace(/^.*\//, "*/")];
+                }
+                if (!destType) {
+                    destType = mediaTypes["*/*"];
+                }
+            }
+            else {
+                destType = mediaTypes["*/*"];
+            }
+            if (!destType) {
+                let binaryBody;
+                try {
+                    binaryBody = yield convertResponseBody(body, this.options.binaryResponseType);
+                }
+                catch (e) {
+                    throw new this.options.errorClass(new URL(response.url), undefined, response, this.options, `Error converting response body: ${getErrorMessage(e)}`);
+                }
+                return {
+                    mediaType,
+                    status: response.status,
+                    body: binaryBody,
+                    response,
+                };
+            }
+            try {
+                const convertedBody = yield convertResponseBody(body, destType);
+                return {
+                    mediaType,
+                    status: response.status,
+                    body: convertedBody.data,
+                    response,
+                };
+            }
+            catch (e) {
+                throw new this.options.errorClass(new URL(response.url), undefined, response, this.options, `Error converting response body: ${getErrorMessage(e)}`);
+            }
+        });
+    }
+    cleanupHeaders(headers) {
+        if (headers === undefined) {
+            return {};
+        }
+        return Object.fromEntries(Object.entries(headers !== null && headers !== void 0 ? headers : {})
+            .filter((header) => header[1] !== undefined && header[1] !== null)
+            .map(([key, value]) => [key.toLowerCase(), value]));
+    }
+    getRequestBody(request) {
+        var _a;
+        if (request.body === undefined) {
+            return undefined;
+        }
+        for (const [key, value] of Object.entries((_a = request.headers) !== null && _a !== void 0 ? _a : {})) {
+            if (key.toLowerCase() === "content-type" &&
+                value &&
+                isJsonMediaType(value)) {
+                return JSON.stringify(request.body);
+            }
+        }
+        return request.body;
+    }
+    preprocessRequest(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestWithHeaders = Object.assign(Object.assign({}, request), { headers: Object.assign(Object.assign({}, this.options.headers), this.cleanupHeaders(request.headers)) });
+            return this.options.preprocessRequest
+                ? this.options.preprocessRequest(requestWithHeaders)
+                : requestWithHeaders;
+        });
+    }
+}
+exports.CommonHttpClient = CommonHttpClient;
+//# sourceMappingURL=CommonHttpClient.js.map