phonic 0.31.2 → 0.31.4

package/dist/cjs/core/logging/logger.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.ConsoleLogger = exports.LogLevel = void 0;
+exports.createLogger = createLogger;
+exports.LogLevel = {
+    Debug: "debug",
+    Info: "info",
+    Warn: "warn",
+    Error: "error",
+};
+const logLevelMap = {
+    [exports.LogLevel.Debug]: 1,
+    [exports.LogLevel.Info]: 2,
+    [exports.LogLevel.Warn]: 3,
+    [exports.LogLevel.Error]: 4,
+};
+/**
+ * Default console-based logger implementation.
+ */
+class ConsoleLogger {
+    debug(message, ...args) {
+        console.debug(message, ...args);
+    }
+    info(message, ...args) {
+        console.info(message, ...args);
+    }
+    warn(message, ...args) {
+        console.warn(message, ...args);
+    }
+    error(message, ...args) {
+        console.error(message, ...args);
+    }
+}
+exports.ConsoleLogger = ConsoleLogger;
+/**
+ * Logger class that provides level-based logging functionality.
+ */
+class Logger {
+    /**
+     * Creates a new logger instance.
+     * @param config - Logger configuration
+     */
+    constructor(config) {
+        this.level = logLevelMap[config.level];
+        this.logger = config.logger;
+        this.silent = config.silent;
+    }
+    /**
+     * Checks if a log level should be output based on configuration.
+     * @param level - The log level to check
+     * @returns True if the level should be logged
+     */
+    shouldLog(level) {
+        return !this.silent && this.level <= logLevelMap[level];
+    }
+    /**
+     * Checks if debug logging is enabled.
+     * @returns True if debug logs should be output
+     */
+    isDebug() {
+        return this.shouldLog(exports.LogLevel.Debug);
+    }
+    /**
+     * Logs a debug message if debug logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    debug(message, ...args) {
+        if (this.isDebug()) {
+            this.logger.debug(message, ...args);
+        }
+    }
+    /**
+     * Checks if info logging is enabled.
+     * @returns True if info logs should be output
+     */
+    isInfo() {
+        return this.shouldLog(exports.LogLevel.Info);
+    }
+    /**
+     * Logs an info message if info logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    info(message, ...args) {
+        if (this.isInfo()) {
+            this.logger.info(message, ...args);
+        }
+    }
+    /**
+     * Checks if warning logging is enabled.
+     * @returns True if warning logs should be output
+     */
+    isWarn() {
+        return this.shouldLog(exports.LogLevel.Warn);
+    }
+    /**
+     * Logs a warning message if warning logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    warn(message, ...args) {
+        if (this.isWarn()) {
+            this.logger.warn(message, ...args);
+        }
+    }
+    /**
+     * Checks if error logging is enabled.
+     * @returns True if error logs should be output
+     */
+    isError() {
+        return this.shouldLog(exports.LogLevel.Error);
+    }
+    /**
+     * Logs an error message if error logging is enabled.
+     * @param message - The message to log
+     * @param args - Additional arguments to log
+     */
+    error(message, ...args) {
+        if (this.isError()) {
+            this.logger.error(message, ...args);
+        }
+    }
+}
+exports.Logger = Logger;
+function createLogger(config) {
+    var _a, _b, _c;
+    if (config == null) {
+        return defaultLogger;
+    }
+    if (config instanceof Logger) {
+        return config;
+    }
+    config = config !== null && config !== void 0 ? config : {};
+    (_a = config.level) !== null && _a !== void 0 ? _a : (config.level = exports.LogLevel.Info);
+    (_b = config.logger) !== null && _b !== void 0 ? _b : (config.logger = new ConsoleLogger());
+    (_c = config.silent) !== null && _c !== void 0 ? _c : (config.silent = true);
+    return new Logger(config);
+}
+const defaultLogger = new Logger({
+    level: exports.LogLevel.Info,
+    logger: new ConsoleLogger(),
+    silent: true,
+});

package/dist/cjs/core/runtime/runtime.js

@@ -71,23 +71,9 @@ function evaluateRuntime() {
             version: Bun.version,
         };
     }
-    /**
-     * A constant that indicates whether the environment the code is running is Node.JS.
-     */
-    const isNode = typeof process !== "undefined" &&
-        "version" in process &&
-        !!process.version &&
-        "versions" in process &&
-        !!((_e = process.versions) === null || _e === void 0 ? void 0 : _e.node);
-    if (isNode) {
-        return {
-            type: "node",
-            version: process.versions.node,
-            parsedVersion: Number(process.versions.node.split(".")[0]),
-        };
-    }
     /**
      * A constant that indicates whether the environment the code is running is in React-Native.
+     * This check should come before Node.js detection since React Native may have a process polyfill.
      * https://github.com/facebook/react-native/blob/main/packages/react-native/Libraries/Core/setUpNavigator.js
      */
     const isReactNative = typeof navigator !== "undefined" && (navigator === null || navigator === void 0 ? void 0 : navigator.product) === "ReactNative";
@@ -96,6 +82,22 @@ function evaluateRuntime() {
             type: "react-native",
         };
     }
+    /**
+     * A constant that indicates whether the environment the code is running is Node.JS.
+     *
+     * We assign `process` to a local variable first to avoid being flagged by
+     * bundlers that perform static analysis on `process.versions` (e.g. Next.js
+     * Edge Runtime warns about Node.js APIs even when they are guarded).
+     */
+    const _process = typeof process !== "undefined" ? process : undefined;
+    const isNode = typeof _process !== "undefined" && typeof ((_e = _process.versions) === null || _e === void 0 ? void 0 : _e.node) === "string";
+    if (isNode) {
+        return {
+            type: "node",
+            version: _process.versions.node,
+            parsedVersion: Number(_process.versions.node.split(".")[0]),
+        };
+    }
     return {
         type: "unknown",
     };

package/dist/cjs/core/url/encodePathParam.d.ts

@@ -0,0 +1 @@
+export declare function encodePathParam(param: unknown): string;

package/dist/cjs/core/url/encodePathParam.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodePathParam = encodePathParam;
+function encodePathParam(param) {
+    if (param === null) {
+        return "null";
+    }
+    const typeofParam = typeof param;
+    switch (typeofParam) {
+        case "undefined":
+            return "undefined";
+        case "string":
+        case "number":
+        case "boolean":
+            break;
+        default:
+            param = String(param);
+            break;
+    }
+    return encodeURIComponent(param);
+}

package/dist/cjs/core/url/index.d.ts

@@ -1,2 +1,3 @@
+export { encodePathParam } from "./encodePathParam.js";
 export { join } from "./join.js";
 export { toQueryString } from "./qs.js";

package/dist/cjs/core/url/index.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toQueryString = exports.join = void 0;
+exports.toQueryString = exports.join = exports.encodePathParam = void 0;
+var encodePathParam_js_1 = require("./encodePathParam.js");
+Object.defineProperty(exports, "encodePathParam", { enumerable: true, get: function () { return encodePathParam_js_1.encodePathParam; } });
 var join_js_1 = require("./join.js");
 Object.defineProperty(exports, "join", { enumerable: true, get: function () { return join_js_1.join; } });
 var qs_js_1 = require("./qs.js");

package/dist/cjs/core/url/join.js

@@ -14,11 +14,10 @@ function join(base, ...segments) {
             url = new URL(base);
         }
         catch (_a) {
-            // Fallback to path joining if URL is malformed
             return joinPath(base, ...segments);
         }
         const lastSegment = segments[segments.length - 1];
-        const shouldPreserveTrailingSlash = lastSegment && lastSegment.endsWith("/");
+        const shouldPreserveTrailingSlash = lastSegment === null || lastSegment === void 0 ? void 0 : lastSegment.endsWith("/");
         for (const segment of segments) {
             const cleanSegment = trimSlashes(segment);
             if (cleanSegment) {
@@ -38,7 +37,7 @@ function joinPath(base, ...segments) {
     }
     let result = base;
     const lastSegment = segments[segments.length - 1];
-    const shouldPreserveTrailingSlash = lastSegment && lastSegment.endsWith("/");
+    const shouldPreserveTrailingSlash = lastSegment === null || lastSegment === void 0 ? void 0 : lastSegment.endsWith("/");
     for (const segment of segments) {
         const cleanSegment = trimSlashes(segment);
         if (cleanSegment) {
@@ -54,7 +53,7 @@ function joinPathSegments(left, right) {
     if (left.endsWith("/")) {
         return left + right;
     }
-    return left + "/" + right;
+    return `${left}/${right}`;
 }
 function trimSlashes(str) {
     if (!str)

package/dist/cjs/core/websocket/exports.d.ts

@@ -0,0 +1,8 @@
+import type * as events from "./events.js";
+import type * as ws from "./ws.js";
+export type ReconnectingWebSocket = typeof ws.ReconnectingWebSocket;
+export declare namespace ReconnectingWebSocket {
+    type Event = events.Event;
+    type CloseEvent = events.CloseEvent;
+    type ErrorEvent = events.ErrorEvent;
+}

package/dist/cjs/core/websocket/exports.js

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

package/dist/cjs/core/websocket/ws.d.ts

@@ -7,8 +7,9 @@ export declare namespace ReconnectingWebSocket {
         url: string;
         protocols?: string | string[];
         options?: ReconnectingWebSocket.Options;
-        headers?: Record<string, any>;
-        queryParameters?: Record<string, string | string[] | object | object[] | null | undefined>;
+        headers?: Record<string, unknown>;
+        queryParameters?: Record<string, unknown>;
+        abortSignal?: AbortSignal;
     }
     type Options = {
         WebSocket?: any;
@@ -47,15 +48,16 @@ export declare class ReconnectingWebSocket {
     private readonly _options;
     private readonly _headers?;
     private readonly _queryParameters?;
-    constructor({ url, protocols, options, headers, queryParameters }: ReconnectingWebSocket.Args);
-    static get CONNECTING(): number;
-    static get OPEN(): number;
-    static get CLOSING(): number;
-    static get CLOSED(): number;
-    get CONNECTING(): number;
-    get OPEN(): number;
-    get CLOSING(): number;
-    get CLOSED(): number;
+    private readonly _abortSignal?;
+    constructor({ url, protocols, options, headers, queryParameters, abortSignal }: ReconnectingWebSocket.Args);
+    static readonly CONNECTING = 0;
+    static readonly OPEN = 1;
+    static readonly CLOSING = 2;
+    static readonly CLOSED = 3;
+    readonly CONNECTING: typeof ReconnectingWebSocket.CONNECTING;
+    readonly OPEN: typeof ReconnectingWebSocket.OPEN;
+    readonly CLOSING: typeof ReconnectingWebSocket.CLOSING;
+    readonly CLOSED: typeof ReconnectingWebSocket.CLOSED;
     get binaryType(): BinaryType;
     set binaryType(value: BinaryType);
     /**
@@ -133,6 +135,7 @@ export declare class ReconnectingWebSocket {
     private _wait;
     private _getNextUrl;
     private _connect;
+    private _handleAbort;
     private _handleTimeout;
     private _disconnect;
     private _acceptOpen;

package/dist/cjs/core/websocket/ws.js

@@ -39,7 +39,6 @@ const index_js_1 = require("../runtime/index.js");
 const qs_js_1 = require("../url/qs.js");
 const Events = __importStar(require("./events.js"));
 const getGlobalWebSocket = () => {
-    // Use Node.js 'ws' library for server-side runtimes since native WebSocket doesn't support headers
     if (index_js_1.RUNTIME.type === "node" || index_js_1.RUNTIME.type === "bun" || index_js_1.RUNTIME.type === "deno") {
         return ws_1.WebSocket;
     }
@@ -65,7 +64,7 @@ const DEFAULT_OPTIONS = {
     debug: false,
 };
 class ReconnectingWebSocket {
-    constructor({ url, protocols, options, headers, queryParameters }) {
+    constructor({ url, protocols, options, headers, queryParameters, abortSignal }) {
         this._listeners = {
             error: [],
             message: [],
@@ -78,6 +77,10 @@ class ReconnectingWebSocket {
         this._binaryType = "blob";
         this._closeCalled = false;
         this._messageQueue = [];
+        this.CONNECTING = ReconnectingWebSocket.CONNECTING;
+        this.OPEN = ReconnectingWebSocket.OPEN;
+        this.CLOSING = ReconnectingWebSocket.CLOSING;
+        this.CLOSED = ReconnectingWebSocket.CLOSED;
         /**
          * An event listener to be called when the WebSocket connection's readyState changes to CLOSED
          */
@@ -95,6 +98,25 @@ class ReconnectingWebSocket {
          * this indicates that the connection is ready to send and receive data
          */
         this.onopen = null;
+        this._handleAbort = () => {
+            if (this._closeCalled) {
+                return;
+            }
+            this._debug("abort signal fired");
+            this._shouldReconnect = false;
+            this._closeCalled = true;
+            this._clearTimeouts();
+            if (this._ws) {
+                this._removeListeners();
+                try {
+                    this._ws.close(1000, "aborted");
+                    this._handleClose(new Events.CloseEvent(1000, "aborted", this));
+                }
+                catch (_error) {
+                    // ignore
+                }
+            }
+        };
         this._handleOpen = (event) => {
             this._debug("open event");
             const { minUptime = DEFAULT_OPTIONS.minUptime } = this._options;
@@ -145,35 +167,15 @@ class ReconnectingWebSocket {
         this._options = options !== null && options !== void 0 ? options : DEFAULT_OPTIONS;
         this._headers = headers;
         this._queryParameters = queryParameters;
+        this._abortSignal = abortSignal;
+        if (this._abortSignal) {
+            this._abortSignal.addEventListener("abort", this._handleAbort, { once: true });
+        }
         if (this._options.startClosed) {
             this._shouldReconnect = false;
         }
         this._connect();
     }
-    static get CONNECTING() {
-        return 0;
-    }
-    static get OPEN() {
-        return 1;
-    }
-    static get CLOSING() {
-        return 2;
-    }
-    static get CLOSED() {
-        return 3;
-    }
-    get CONNECTING() {
-        return ReconnectingWebSocket.CONNECTING;
-    }
-    get OPEN() {
-        return ReconnectingWebSocket.OPEN;
-    }
-    get CLOSING() {
-        return ReconnectingWebSocket.CLOSING;
-    }
-    get CLOSED() {
-        return ReconnectingWebSocket.CLOSED;
-    }
     get binaryType() {
         return this._ws ? this._ws.binaryType : this._binaryType;
     }
@@ -331,7 +333,7 @@ class ReconnectingWebSocket {
         const { reconnectionDelayGrowFactor = DEFAULT_OPTIONS.reconnectionDelayGrowFactor, minReconnectionDelay = DEFAULT_OPTIONS.minReconnectionDelay, maxReconnectionDelay = DEFAULT_OPTIONS.maxReconnectionDelay, } = this._options;
         let delay = 0;
         if (this._retryCount > 0) {
-            delay = minReconnectionDelay * Math.pow(reconnectionDelayGrowFactor, this._retryCount - 1);
+            delay = minReconnectionDelay * Math.pow(reconnectionDelayGrowFactor, (this._retryCount - 1));
             if (delay > maxReconnectionDelay) {
                 delay = maxReconnectionDelay;
             }
@@ -361,9 +363,14 @@ class ReconnectingWebSocket {
         throw Error("Invalid URL");
     }
     _connect() {
+        var _a;
         if (this._connectLock || !this._shouldReconnect) {
             return;
         }
+        if ((_a = this._abortSignal) === null || _a === void 0 ? void 0 : _a.aborted) {
+            this._debug("connect aborted");
+            return;
+        }
         this._connectLock = true;
         const { maxRetries = DEFAULT_OPTIONS.maxRetries, connectionTimeout = DEFAULT_OPTIONS.connectionTimeout, WebSocket = getGlobalWebSocket(), } = this._options;
         if (this._retryCount >= maxRetries) {
@@ -379,7 +386,9 @@ class ReconnectingWebSocket {
         this._wait()
             .then(() => this._getNextUrl(this._url))
             .then((url) => {
-            if (this._closeCalled) {
+            var _a;
+            if (this._closeCalled || ((_a = this._abortSignal) === null || _a === void 0 ? void 0 : _a.aborted)) {
+                this._connectLock = false;
                 return;
             }
             const options = {};
@@ -413,7 +422,7 @@ class ReconnectingWebSocket {
             this._ws.close(code, reason);
             this._handleClose(new Events.CloseEvent(code, reason, this));
         }
-        catch (error) {
+        catch (_error) {
             // ignore
         }
     }
@@ -459,3 +468,7 @@ class ReconnectingWebSocket {
     }
 }
 exports.ReconnectingWebSocket = ReconnectingWebSocket;
+ReconnectingWebSocket.CONNECTING = 0;
+ReconnectingWebSocket.OPEN = 1;
+ReconnectingWebSocket.CLOSING = 2;
+ReconnectingWebSocket.CLOSED = 3;

package/dist/cjs/environments.d.ts

@@ -1,6 +1,3 @@
-/**
- * This file was auto-generated by Fern from our API Definition.
- */
 export interface PhonicEnvironmentUrls {
     base: string;
     production: string;

package/dist/cjs/environments.js

@@ -1,7 +1,5 @@
 "use strict";
-/**
- * This file was auto-generated by Fern from our API Definition.
- */
+// This file was auto-generated by Fern from our API Definition.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PhonicEnvironment = void 0;
 exports.PhonicEnvironment = {

package/dist/cjs/errors/PhonicError.d.ts

@@ -1,7 +1,4 @@
-/**
- * This file was auto-generated by Fern from our API Definition.
- */
-import * as core from "../core/index.js";
+import type * as core from "../core/index.js";
 export declare class PhonicError extends Error {
     readonly statusCode?: number;
     readonly body?: unknown;

package/dist/cjs/errors/PhonicError.js

@@ -1,14 +1,16 @@
 "use strict";
-/**
- * This file was auto-generated by Fern from our API Definition.
- */
+// This file was auto-generated by Fern from our API Definition.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PhonicError = void 0;
 const json_js_1 = require("../core/json.js");
 class PhonicError extends Error {
     constructor({ message, statusCode, body, rawResponse, }) {
         super(buildMessage({ message, statusCode, body }));
-        Object.setPrototypeOf(this, PhonicError.prototype);
+        Object.setPrototypeOf(this, new.target.prototype);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+        this.name = this.constructor.name;
         this.statusCode = statusCode;
         this.body = body;
         this.rawResponse = rawResponse;
@@ -16,7 +18,7 @@ class PhonicError extends Error {
 }
 exports.PhonicError = PhonicError;
 function buildMessage({ message, statusCode, body, }) {
-    let lines = [];
+    const lines = [];
     if (message != null) {
         lines.push(message);
     }

package/dist/cjs/errors/PhonicTimeoutError.d.ts

@@ -1,6 +1,3 @@
-/**
- * This file was auto-generated by Fern from our API Definition.
- */
 export declare class PhonicTimeoutError extends Error {
     constructor(message: string);
 }

package/dist/cjs/errors/PhonicTimeoutError.js

@@ -1,13 +1,15 @@
 "use strict";
-/**
- * This file was auto-generated by Fern from our API Definition.
- */
+// This file was auto-generated by Fern from our API Definition.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PhonicTimeoutError = void 0;
 class PhonicTimeoutError extends Error {
     constructor(message) {
         super(message);
-        Object.setPrototypeOf(this, PhonicTimeoutError.prototype);
+        Object.setPrototypeOf(this, new.target.prototype);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+        this.name = this.constructor.name;
     }
 }
 exports.PhonicTimeoutError = PhonicTimeoutError;

package/dist/cjs/errors/handleNonStatusCodeError.d.ts

@@ -0,0 +1,2 @@
+import type * as core from "../core/index.js";
+export declare function handleNonStatusCodeError(error: core.Fetcher.Error, rawResponse: core.RawResponse, method: string, path: string): never;

package/dist/cjs/errors/handleNonStatusCodeError.js

@@ -0,0 +1,65 @@
+"use strict";
+// This file was auto-generated by Fern from our API Definition.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleNonStatusCodeError = handleNonStatusCodeError;
+const errors = __importStar(require("./index.js"));
+function handleNonStatusCodeError(error, rawResponse, method, path) {
+    switch (error.reason) {
+        case "non-json":
+            throw new errors.PhonicError({
+                statusCode: error.statusCode,
+                body: error.rawBody,
+                rawResponse: rawResponse,
+            });
+        case "body-is-null":
+            throw new errors.PhonicError({
+                statusCode: error.statusCode,
+                rawResponse: rawResponse,
+            });
+        case "timeout":
+            throw new errors.PhonicTimeoutError(`Timeout exceeded when calling ${method} ${path}.`);
+        case "unknown":
+            throw new errors.PhonicError({
+                message: error.errorMessage,
+                rawResponse: rawResponse,
+            });
+        default:
+            throw new errors.PhonicError({
+                message: "Unknown error",
+                rawResponse: rawResponse,
+            });
+    }
+}

package/dist/cjs/exports.d.ts

@@ -0,0 +1 @@
+export * from "./core/exports.js";

package/dist/cjs/exports.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./core/exports.js"), exports);

package/dist/cjs/index.d.ts

@@ -1,4 +1,6 @@
 export * as Phonic from "./api/index.js";
-export { PhonicError, PhonicTimeoutError } from "./errors/index.js";
+export type { BaseClientOptions, BaseRequestOptions } from "./BaseClient.js";
 export { PhonicClient } from "./Client.js";
-export { PhonicEnvironment, PhonicEnvironmentUrls } from "./environments.js";
+export { PhonicEnvironment, type PhonicEnvironmentUrls } from "./environments.js";
+export { PhonicError, PhonicTimeoutError } from "./errors/index.js";
+export * from "./exports.js";