@pexcode/dlis-sdk 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 pexcode
+
+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 the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,332 @@
+# @pexcode/dlis-sdk
+
+Official TypeScript/JavaScript SDK from [Pexcode](https://pexcode.com) for integrating with the **DLIS API** (delivery and logistics management platform).
+
+The SDK supports package creation, cost calculation, branch and region management, ledger tracking, and webhook configuration.
+
+---
+
+## Requirements
+
+- Node.js 18 or later
+- API token from the DLIS dashboard
+- DLIS API base URL
+
+---
+
+## Installation
+
+```bash
+npm install @pexcode/dlis-sdk
+```
+
+---
+
+## Quick Start
+
+```typescript
+import { DLISystem } from "@pexcode/dlis-sdk";
+
+const dlis = new DLISystem(
+  "https://your-api-base-url.com", // DLIS API base URL
+  "your-api-token"                  // API token
+);
+
+// Verify connected SDK app info
+const info = await dlis.MyInfo();
+console.log(info);
+```
+
+> **Note:** The SDK automatically uses API version `v3` via the `x-version` header.
+
+### Backward Compatibility
+
+For backward compatibility, you can import the legacy name `QDSystem` instead of `DLISystem`:
+
+```typescript
+import { QDSystem } from "@pexcode/dlis-sdk";
+
+const dlis = new QDSystem("https://your-api-base-url.com", "your-api-token");
+```
+
+---
+
+## Typical Workflow
+
+Common steps to create a new package:
+
+```
+1. Fetch regions
+2. Fetch cities
+3. Fetch company branches in the city
+4. Calculate shipping cost
+5. Check blacklist (optional)
+6. Create the package
+7. Send package data to the center
+```
+
+```typescript
+import { DLISystem } from "@pexcode/dlis-sdk";
+
+const dlis = new DLISystem("https://your-api-base-url.com", "your-api-token");
+
+const countryId = 1;
+const regions = await dlis.GetRegionsList(countryId);
+const cities = await dlis.GetCitiesListInByRegion(regions[0].id);
+
+const cityId = cities[0].id;
+const branches = await dlis.getCompanyListOfCity(cityId);
+const branch = branches[0];
+
+const cost = await dlis.CalculateCost({
+  costId: branch.costModel![0].id,
+  branchId: branch.id,
+  receiverCityId: cityId,
+  receiverAddress: "10 Example Street",
+  shippingOption: "standard",
+  isPickup: false,
+  weight: 2,
+});
+
+await dlis.CheckBlackList({
+  phone: "+966500000000",
+  firstName: "John",
+  lastName: "Doe",
+});
+
+const pkg = await dlis.CreatePackage({
+  weight: 2,
+  shippingOption: "standard",
+  billingType: "prepaid",
+  proofOfDeliveryType: "signature",
+  branchId: branch.id,
+  costId: branch.costModel![0].id,
+  type: "Package",
+  note: "Store order",
+  pickup: false,
+  includeProducts: false,
+  isTesting: false,
+  receiverInfo: {
+    firstName: "John",
+    lastName: "Doe",
+    address: "10 Example Street",
+    phone: "+966500000000",
+    cityId,
+  },
+});
+
+await dlis.SendDataToCenter(pkg.id);
+```
+
+---
+
+## API Reference
+
+### App Info & Branches
+
+| Method | Description |
+|--------|-------------|
+| `MyInfo()` | Returns connected SDK app info (status, limits, webhook, etc.) |
+| `getTenantBranches()` | Fetches all tenant branches |
+| `getCompanyListOfCity(cityId)` | Fetches company branches available in a given city |
+
+```typescript
+const info = await dlis.MyInfo();
+const branches = await dlis.getTenantBranches();
+const cityBranches = await dlis.getCompanyListOfCity(42);
+```
+
+---
+
+### Regions & Cities
+
+| Method | Description |
+|--------|-------------|
+| `GetRegionsList(countryId)` | Fetches regions for a given country |
+| `GetCitiesListInByRegion(regionId)` | Fetches cities within a given region |
+
+```typescript
+const regions = await dlis.GetRegionsList(1);
+const cities = await dlis.GetCitiesListInByRegion(regions[0].id);
+```
+
+---
+
+### Packages
+
+| Method | Description |
+|--------|-------------|
+| `GetList(page?, pageSize?)` | Fetches paginated package list (default: page 1, 10 items) |
+| `GetPackageDetails(id)` | Fetches a single package by ID |
+| `CreatePackage(payload)` | Creates a new package |
+| `CancelOne(id)` | Cancels a package |
+| `ReportOne(id, body)` | Reports an issue with a package |
+| `SendDataToCenter(id)` | Sends package data to the center after preparation |
+
+```typescript
+const packages = await dlis.GetList(1, 20);
+const details = await dlis.GetPackageDetails("package-id");
+const created = await dlis.CreatePackage({ /* ... */ });
+await dlis.CancelOne("package-id");
+await dlis.ReportOne("package-id", { reason: "Delivery delayed" });
+await dlis.SendDataToCenter("package-id");
+```
+
+---
+
+### Cost & Validation
+
+| Method | Description |
+|--------|-------------|
+| `CalculateCost(params)` | Calculates shipping cost before creating a package |
+| `CheckBlackList(query)` | Checks receiver details against the blacklist |
+
+```typescript
+const cost = await dlis.CalculateCost({
+  costId: "cost-id",
+  branchId: "branch-id",
+  receiverCityId: 42,
+  receiverAddress: "10 Example Street",
+  receiverLat: 24.7136,
+  receiverLng: 46.6753,
+  shippingOption: "express",
+  isPickup: true,
+  weight: 3,
+});
+
+const blacklistCheck = await dlis.CheckBlackList({
+  phone: "+966500000000",
+  email: "user@example.com",
+});
+```
+
+---
+
+### Ledger
+
+| Method | Description |
+|--------|-------------|
+| `GetMyLedgerOverview()` | Summary of current balance and unpaid amounts |
+| `GetMyLedger(year?, month?)` | Financial transaction history (optional year and month) |
+
+```typescript
+const overview = await dlis.GetMyLedgerOverview();
+// overview.currentBalance, overview.unpaidIncome, overview.unpaidExpenses, overview.expectedBalance
+
+const ledger = await dlis.GetMyLedger(2026, 7);
+```
+
+---
+
+### Webhook
+
+| Method | Description |
+|--------|-------------|
+| `SetWebhook(payload)` | Registers a webhook URL to receive update notifications |
+
+```typescript
+await dlis.SetWebhook({
+  host: "https://your-server.com",
+  path: "/webhooks/dlis",
+  webhookToken: "your-secret-token",
+});
+```
+
+---
+
+## Main Data Types
+
+### Create Package — `SdkPackagesCreationAttributes`
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `weight` | `number` | Yes | Package weight in kilograms |
+| `shippingOption` | `ShippingOption` | Yes | Shipping type |
+| `billingType` | `BillingType` | Yes | Billing type |
+| `proofOfDeliveryType` | `ProofOfDeliveryType` | Yes | Proof of delivery |
+| `branchId` | `string` | Yes | Branch ID |
+| `costId` | `string` | Yes | Cost model ID |
+| `type` | `PackageType` | Yes | Package type |
+| `note` | `string` | Yes | Notes |
+| `pickup` | `boolean` | Yes | Pickup from branch? |
+| `includeProducts` | `boolean` | Yes | Includes products? |
+| `isTesting` | `boolean` | Yes | Test package |
+| `receiverInfo` | `ClientCreationAttributes` | Yes | Receiver details |
+| `futureTenantId` | `string` | No | Future tenant ID |
+| `packageCost` | `number` | No | Package contents value |
+| `endpoint` | `string` | No | Specific delivery endpoint |
+
+### Receiver Info — `ClientCreationAttributes`
+
+| Field | Type | Required |
+|-------|------|----------|
+| `firstName` | `string` | Yes |
+| `lastName` | `string` | Yes |
+| `address` | `string` | Yes |
+| `phone` | `string` | Yes |
+| `cityId` | `number` | Yes |
+| `postCode` | `string` | No |
+| `email` | `string` | No |
+| `lng` / `lat` | `number` | No |
+| `houseNumber` | `string` | No |
+
+---
+
+## Enums
+
+### `ShippingOption`
+
+| Value | Description |
+|-------|-------------|
+| `standard` | Standard shipping |
+| `express` | Express shipping |
+| `same_day` | Same-day delivery |
+
+### `BillingType`
+
+| Value | Description |
+|-------|-------------|
+| `none` | No billing |
+| `prepaid` | Prepaid |
+| `postpaid` | Cash on delivery |
+
+### `ProofOfDeliveryType`
+
+| Value | Description |
+|-------|-------------|
+| `none` | No proof required |
+| `signature` | Receiver signature |
+| `otp` | One-time password (OTP) |
+
+### `PackageType`
+
+| Value | Description |
+|-------|-------------|
+| `Package` | Package |
+| `Document` | Document |
+
+---
+
+## Error Handling
+
+When a request fails, the SDK throws an `Error` with the server message. Handle it like this:
+
+```typescript
+try {
+  const pkg = await dlis.CreatePackage(payload);
+} catch (error) {
+  console.error("Failed to create package:", (error as Error).message);
+}
+```
+
+---
+
+## TypeScript
+
+The SDK is written in TypeScript and ships with type definitions. All request and response types are available when importing from the package.
+
+---
+
+## License
+
+MIT — © Pexcode

package/dist/api/core/ApiError.d.ts

@@ -0,0 +1,10 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { ApiResult } from './ApiResult';
+export declare class ApiError extends Error {
+    readonly url: string;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+    readonly request: ApiRequestOptions;
+    constructor(request: ApiRequestOptions, response: ApiResult, message: string);
+}

package/dist/api/core/ApiError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiError = void 0;
+class ApiError extends Error {
+    constructor(request, response, message) {
+        super(message);
+        this.name = 'ApiError';
+        this.url = response.url;
+        this.status = response.status;
+        this.statusText = response.statusText;
+        this.body = response.body;
+        this.request = request;
+    }
+}
+exports.ApiError = ApiError;

package/dist/api/core/ApiRequestOptions.d.ts

@@ -0,0 +1,13 @@
+export type ApiRequestOptions = {
+    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
+    readonly url: string;
+    readonly path?: Record<string, any>;
+    readonly cookies?: Record<string, any>;
+    readonly headers?: Record<string, any>;
+    readonly query?: Record<string, any>;
+    readonly formData?: Record<string, any>;
+    readonly body?: any;
+    readonly mediaType?: string;
+    readonly responseHeader?: string;
+    readonly errors?: Record<number, string>;
+};

package/dist/api/core/ApiRequestOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/api/core/ApiResult.d.ts

@@ -0,0 +1,7 @@
+export type ApiResult = {
+    readonly url: string;
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+};

package/dist/api/core/ApiResult.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/api/core/CancelablePromise.d.ts

@@ -0,0 +1,20 @@
+export declare class CancelError extends Error {
+    constructor(message: string);
+    get isCancelled(): boolean;
+}
+export interface OnCancel {
+    readonly isResolved: boolean;
+    readonly isRejected: boolean;
+    readonly isCancelled: boolean;
+    (cancelHandler: () => void): void;
+}
+export declare class CancelablePromise<T> implements Promise<T> {
+    #private;
+    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancel: OnCancel) => void);
+    get [Symbol.toStringTag](): string;
+    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onFinally?: (() => void) | null): Promise<T>;
+    cancel(): void;
+    get isCancelled(): boolean;
+}

package/dist/api/core/CancelablePromise.js

@@ -0,0 +1,116 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _CancelablePromise_isResolved, _CancelablePromise_isRejected, _CancelablePromise_isCancelled, _CancelablePromise_cancelHandlers, _CancelablePromise_promise, _CancelablePromise_resolve, _CancelablePromise_reject;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CancelablePromise = exports.CancelError = void 0;
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+class CancelError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CancelError';
+    }
+    get isCancelled() {
+        return true;
+    }
+}
+exports.CancelError = CancelError;
+class CancelablePromise {
+    constructor(executor) {
+        _CancelablePromise_isResolved.set(this, void 0);
+        _CancelablePromise_isRejected.set(this, void 0);
+        _CancelablePromise_isCancelled.set(this, void 0);
+        _CancelablePromise_cancelHandlers.set(this, void 0);
+        _CancelablePromise_promise.set(this, void 0);
+        _CancelablePromise_resolve.set(this, void 0);
+        _CancelablePromise_reject.set(this, void 0);
+        __classPrivateFieldSet(this, _CancelablePromise_isResolved, false, "f");
+        __classPrivateFieldSet(this, _CancelablePromise_isRejected, false, "f");
+        __classPrivateFieldSet(this, _CancelablePromise_isCancelled, false, "f");
+        __classPrivateFieldSet(this, _CancelablePromise_cancelHandlers, [], "f");
+        __classPrivateFieldSet(this, _CancelablePromise_promise, new Promise((resolve, reject) => {
+            __classPrivateFieldSet(this, _CancelablePromise_resolve, resolve, "f");
+            __classPrivateFieldSet(this, _CancelablePromise_reject, reject, "f");
+            const onResolve = (value) => {
+                if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
+                    return;
+                }
+                __classPrivateFieldSet(this, _CancelablePromise_isResolved, true, "f");
+                if (__classPrivateFieldGet(this, _CancelablePromise_resolve, "f"))
+                    __classPrivateFieldGet(this, _CancelablePromise_resolve, "f").call(this, value);
+            };
+            const onReject = (reason) => {
+                if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
+                    return;
+                }
+                __classPrivateFieldSet(this, _CancelablePromise_isRejected, true, "f");
+                if (__classPrivateFieldGet(this, _CancelablePromise_reject, "f"))
+                    __classPrivateFieldGet(this, _CancelablePromise_reject, "f").call(this, reason);
+            };
+            const onCancel = (cancelHandler) => {
+                if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
+                    return;
+                }
+                __classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f").push(cancelHandler);
+            };
+            Object.defineProperty(onCancel, 'isResolved', {
+                get: () => __classPrivateFieldGet(this, _CancelablePromise_isResolved, "f"),
+            });
+            Object.defineProperty(onCancel, 'isRejected', {
+                get: () => __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f"),
+            });
+            Object.defineProperty(onCancel, 'isCancelled', {
+                get: () => __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f"),
+            });
+            return executor(onResolve, onReject, onCancel);
+        }), "f");
+    }
+    get [(_CancelablePromise_isResolved = new WeakMap(), _CancelablePromise_isRejected = new WeakMap(), _CancelablePromise_isCancelled = new WeakMap(), _CancelablePromise_cancelHandlers = new WeakMap(), _CancelablePromise_promise = new WeakMap(), _CancelablePromise_resolve = new WeakMap(), _CancelablePromise_reject = new WeakMap(), Symbol.toStringTag)]() {
+        return "Cancellable Promise";
+    }
+    then(onFulfilled, onRejected) {
+        return __classPrivateFieldGet(this, _CancelablePromise_promise, "f").then(onFulfilled, onRejected);
+    }
+    catch(onRejected) {
+        return __classPrivateFieldGet(this, _CancelablePromise_promise, "f").catch(onRejected);
+    }
+    finally(onFinally) {
+        return __classPrivateFieldGet(this, _CancelablePromise_promise, "f").finally(onFinally);
+    }
+    cancel() {
+        if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
+            return;
+        }
+        __classPrivateFieldSet(this, _CancelablePromise_isCancelled, true, "f");
+        if (__classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f").length) {
+            try {
+                for (const cancelHandler of __classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f")) {
+                    cancelHandler();
+                }
+            }
+            catch (error) {
+                console.warn('Cancellation threw an error', error);
+                return;
+            }
+        }
+        __classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f").length = 0;
+        if (__classPrivateFieldGet(this, _CancelablePromise_reject, "f"))
+            __classPrivateFieldGet(this, _CancelablePromise_reject, "f").call(this, new CancelError('Request aborted'));
+    }
+    get isCancelled() {
+        return __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f");
+    }
+}
+exports.CancelablePromise = CancelablePromise;

package/dist/api/core/OpenAPI.d.ts

@@ -0,0 +1,16 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+type Headers = Record<string, string>;
+export type OpenAPIConfig = {
+    BASE: string;
+    VERSION: string;
+    WITH_CREDENTIALS: boolean;
+    CREDENTIALS: 'include' | 'omit' | 'same-origin';
+    TOKEN?: string | Resolver<string> | undefined;
+    USERNAME?: string | Resolver<string> | undefined;
+    PASSWORD?: string | Resolver<string> | undefined;
+    HEADERS?: Headers | Resolver<Headers> | undefined;
+    ENCODE_PATH?: ((path: string) => string) | undefined;
+};
+export declare const OpenAPI: OpenAPIConfig;
+export {};

package/dist/api/core/OpenAPI.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAPI = void 0;
+exports.OpenAPI = {
+    BASE: '',
+    VERSION: '1.0.0',
+    WITH_CREDENTIALS: false,
+    CREDENTIALS: 'include',
+    TOKEN: undefined,
+    USERNAME: undefined,
+    PASSWORD: undefined,
+    HEADERS: undefined,
+    ENCODE_PATH: undefined,
+};

package/dist/api/core/request.d.ts

@@ -0,0 +1,34 @@
+import type { AxiosResponse, AxiosInstance } from 'axios';
+import FormData from 'form-data';
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { ApiResult } from './ApiResult';
+import { CancelablePromise } from './CancelablePromise';
+import type { OnCancel } from './CancelablePromise';
+import type { OpenAPIConfig } from './OpenAPI';
+export declare const isDefined: <T>(value: T | null | undefined) => value is Exclude<T, null | undefined>;
+export declare const isString: (value: any) => value is string;
+export declare const isStringWithValue: (value: any) => value is string;
+export declare const isBlob: (value: any) => value is Blob;
+export declare const isFormData: (value: any) => value is FormData;
+export declare const isSuccess: (status: number) => boolean;
+export declare const base64: (str: string) => string;
+export declare const getQueryString: (params: Record<string, any>) => string;
+export declare const getFormData: (options: ApiRequestOptions) => FormData | undefined;
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+export declare const resolve: <T>(options: ApiRequestOptions, resolver?: T | Resolver<T>) => Promise<T | undefined>;
+export declare const getHeaders: (config: OpenAPIConfig, options: ApiRequestOptions, formData?: FormData) => Promise<Record<string, string>>;
+export declare const getRequestBody: (options: ApiRequestOptions) => any;
+export declare const sendRequest: <T>(config: OpenAPIConfig, options: ApiRequestOptions, url: string, body: any, formData: FormData | undefined, headers: Record<string, string>, onCancel: OnCancel, axiosClient: AxiosInstance) => Promise<AxiosResponse<T>>;
+export declare const getResponseHeader: (response: AxiosResponse<any>, responseHeader?: string) => string | undefined;
+export declare const getResponseBody: (response: AxiosResponse<any>) => any;
+export declare const catchErrorCodes: (options: ApiRequestOptions, result: ApiResult) => void;
+/**
+ * Request method
+ * @param config The OpenAPI configuration object
+ * @param options The request options from the service
+ * @param axiosClient The axios client instance to use
+ * @returns CancelablePromise<T>
+ * @throws ApiError
+ */
+export declare const request: <T>(config: OpenAPIConfig, options: ApiRequestOptions, axiosClient?: AxiosInstance) => CancelablePromise<T>;
+export {};