apimo.js 1.0.4 → 1.1.0

package/dist/core/api.js

@@ -1,15 +1,7 @@
-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());
-    });
-};
 import Bottleneck from 'bottleneck';
 import { merge } from 'merge-anything';
 import { z } from 'zod';
+import { ApiConfigurationError, ApiResponseValidationError, ApiRetryExhaustedError, isRetryable, throwForStatus, } from '../errors';
 import { getAgencySchema } from '../schemas/agency';
 import { CatalogDefinitionSchema, CatalogEntrySchema } from '../schemas/common';
 import { getPropertySchema } from '../schemas/property';
@@ -30,6 +22,11 @@ export const DEFAULT_ADDITIONAL_CONFIG = {
             active: true,
         },
     },
+    retry: {
+        attempts: 3,
+        initialDelayMs: 200,
+        backoff: 'exponential',
+    },
 };
 export class Apimo {
     constructor(
@@ -41,7 +38,23 @@ export class Apimo {
     config = DEFAULT_ADDITIONAL_CONFIG) {
         this.provider = provider;
         this.token = token;
+        if (!provider || provider.trim() === '') {
+            throw new ApiConfigurationError('provider must be a non-empty string.');
+        }
+        if (!token || token.trim() === '') {
+            throw new ApiConfigurationError('token must be a non-empty string.');
+        }
         this.config = merge(DEFAULT_ADDITIONAL_CONFIG, config);
+        if (!this.config.baseUrl || this.config.baseUrl.trim() === '') {
+            throw new ApiConfigurationError('baseUrl must be a non-empty string.');
+        }
+        try {
+            // eslint-disable-next-line no-new
+            new URL(this.config.baseUrl);
+        }
+        catch (_a) {
+            throw new ApiConfigurationError(`baseUrl "${this.config.baseUrl}" is not a valid URL.`);
+        }
         this.cache = this.config.catalogs.cache.active ? this.config.catalogs.cache.adapter : new DummyCache();
         this.limiter = new Bottleneck({
             reservoir: 10,
@@ -57,79 +70,108 @@ export class Apimo {
         const extendedInit = Object.assign(Object.assign({}, init), { headers: Object.assign({ Authorization: `Basic ${btoa(`${this.provider}:${this.token}`)}` }, init === null || init === void 0 ? void 0 : init.headers) });
         return this.limiter.schedule(() => fetch(input, extendedInit));
     }
-    get(path, schema, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.fetch(makeApiUrl(path, this.config, Object.assign({ culture: this.config.culture }, options)));
-            if (!response.ok) {
-                throw new Error(yield response.json());
+    async get(path, schema, options) {
+        const url = makeApiUrl(path, this.config, Object.assign({ culture: this.config.culture }, options));
+        const { attempts, initialDelayMs, backoff } = this.config.retry;
+        let lastError;
+        for (let attempt = 1; attempt <= attempts; attempt++) {
+            try {
+                const response = await this.fetch(url);
+                if (!response.ok) {
+                    let responseBody;
+                    try {
+                        responseBody = await response.json();
+                    }
+                    catch (_a) {
+                        // The body wasn't JSON — leave responseBody as undefined
+                    }
+                    throwForStatus(response.status, url.toString(), responseBody);
+                }
+                const json = await response.json();
+                const result = await schema.safeParseAsync(json);
+                if (!result.success) {
+                    throw new ApiResponseValidationError(url.toString(), result.error);
+                }
+                return result.data;
             }
-            return schema.parseAsync(yield response.json());
-        });
+            catch (error) {
+                lastError = error;
+                const hasMoreAttempts = attempt < attempts;
+                if (!isRetryable(error)) {
+                    // Non-transient errors (4xx, schema failures, etc.) — propagate immediately
+                    throw error;
+                }
+                if (!hasMoreAttempts) {
+                    break;
+                }
+                await this.sleep(this.retryDelayMs(attempt, initialDelayMs, backoff));
+            }
+        }
+        throw new ApiRetryExhaustedError(attempts, lastError);
     }
-    fetchCatalogs() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.get(['catalogs'], z.array(CatalogDefinitionSchema));
-        });
+    async fetchCatalogs() {
+        return this.get(['catalogs'], z.array(CatalogDefinitionSchema));
     }
-    populateCache(catalogName, culture, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const catalog = yield this.fetchCatalog(catalogName, { culture });
-            yield this.cache.setEntries(catalogName, culture, catalog);
-            if (id !== undefined) {
-                const queriedKey = catalog.find(({ id: entryId }) => entryId === id);
-                return queriedKey
-                    ? {
-                        name: queriedKey.name,
-                        namePlural: queriedKey.name_plurial,
-                    }
-                    : null;
-            }
-        });
+    async populateCache(catalogName, culture, id) {
+        const catalog = await this.fetchCatalog(catalogName, { culture });
+        await this.cache.setEntries(catalogName, culture, catalog);
+        if (id !== undefined) {
+            const queriedKey = catalog.find(({ id: entryId }) => entryId === id);
+            return queriedKey
+                ? {
+                    name: queriedKey.name,
+                    namePlural: queriedKey.name_plurial,
+                }
+                : null;
+        }
     }
-    getCatalogEntries(catalogName, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
-            try {
-                return yield this.cache.getEntries(catalogName, (_a = options === null || options === void 0 ? void 0 : options.culture) !== null && _a !== void 0 ? _a : this.config.culture);
+    async getCatalogEntries(catalogName, options) {
+        var _a, _b, _c;
+        try {
+            return await this.cache.getEntries(catalogName, (_a = options === null || options === void 0 ? void 0 : options.culture) !== null && _a !== void 0 ? _a : this.config.culture);
+        }
+        catch (e) {
+            if (e instanceof CacheExpiredError) {
+                await this.populateCache(catalogName, (_b = options === null || options === void 0 ? void 0 : options.culture) !== null && _b !== void 0 ? _b : this.config.culture);
+                return this.cache.getEntries(catalogName, (_c = options === null || options === void 0 ? void 0 : options.culture) !== null && _c !== void 0 ? _c : this.config.culture);
             }
-            catch (e) {
-                if (e instanceof CacheExpiredError) {
-                    yield this.populateCache(catalogName, (_b = options === null || options === void 0 ? void 0 : options.culture) !== null && _b !== void 0 ? _b : this.config.culture);
-                    return this.cache.getEntries(catalogName, (_c = options === null || options === void 0 ? void 0 : options.culture) !== null && _c !== void 0 ? _c : this.config.culture);
-                }
-                else {
-                    throw e;
-                }
+            else {
+                throw e;
             }
-        });
+        }
     }
-    fetchCatalog(catalogName, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.get(['catalogs', catalogName], z.array(CatalogEntrySchema), options);
-        });
+    async fetchCatalog(catalogName, options) {
+        return this.get(['catalogs', catalogName], z.array(CatalogEntrySchema), options);
     }
-    fetchAgencies(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            return this.get(['agencies'], z.object({
-                total_items: z.number(),
-                agencies: getAgencySchema(this.getLocalizedCatalogTransformer((_a = options === null || options === void 0 ? void 0 : options.culture) !== null && _a !== void 0 ? _a : this.config.culture), this.config).array(),
-                timestamp: z.number(),
-            }));
-        });
+    async fetchAgencies(options) {
+        var _a;
+        return this.get(['agencies'], z.object({
+            total_items: z.number(),
+            agencies: getAgencySchema(this.getLocalizedCatalogTransformer((_a = options === null || options === void 0 ? void 0 : options.culture) !== null && _a !== void 0 ? _a : this.config.culture), this.config).array(),
+            timestamp: z.number(),
+        }));
     }
-    fetchProperties(agencyId, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            return this.get(['agencies', agencyId.toString(), 'properties'], z.object({
-                total_items: z.number(),
-                timestamp: z.number(),
-                properties: getPropertySchema(this.getLocalizedCatalogTransformer((_a = options === null || options === void 0 ? void 0 : options.culture) !== null && _a !== void 0 ? _a : this.config.culture)).array(),
-            }), options);
-        });
+    async fetchProperties(agencyId, options) {
+        var _a;
+        return this.get(['agencies', agencyId.toString(), 'properties'], z.object({
+            total_items: z.number(),
+            timestamp: z.number(),
+            properties: getPropertySchema(this.getLocalizedCatalogTransformer((_a = options === null || options === void 0 ? void 0 : options.culture) !== null && _a !== void 0 ? _a : this.config.culture)).array(),
+        }), options);
+    }
+    /** Calculates the delay before the next retry attempt (1-based attempt index). */
+    retryDelayMs(attempt, initialDelayMs, backoff) {
+        switch (backoff) {
+            case 'exponential': return initialDelayMs * 2 ** (attempt - 1);
+            case 'linear': return initialDelayMs * attempt;
+            case 'fixed': return initialDelayMs;
+        }
+    }
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
     }
     getLocalizedCatalogTransformer(culture) {
-        return (catalogName, id) => __awaiter(this, void 0, void 0, function* () {
+        return async (catalogName, id) => {
             if (!this.config.catalogs.transform.active) {
                 return `${catalogName}.${id}`;
             }
@@ -137,21 +179,19 @@ export class Apimo {
                 return this.config.catalogs.transform.transformFn(catalogName, culture, id);
             }
             return this.catalogTransformer(catalogName, culture, id);
-        });
+        };
     }
-    catalogTransformer(catalogName, culture, id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield this.cache.getEntry(catalogName, culture, id);
+    async catalogTransformer(catalogName, culture, id) {
+        try {
+            return await this.cache.getEntry(catalogName, culture, id);
+        }
+        catch (e) {
+            if (e instanceof CacheExpiredError) {
+                return await this.populateCache(catalogName, culture, id);
             }
-            catch (e) {
-                if (e instanceof CacheExpiredError) {
-                    return yield this.populateCache(catalogName, culture, id);
-                }
-                else {
-                    throw e;
-                }
+            else {
+                throw e;
             }
-        });
+        }
     }
 }

package/dist/errors/index.d.ts

@@ -0,0 +1,176 @@
+import type { ZodError } from 'zod';
+/**
+ * Base class for all Apimo errors.
+ * All errors thrown by the library extend this class, so you can catch them all with `catch (e) { if (e instanceof ApimoError) ... }`.
+ */
+export declare class ApimoError extends Error {
+    constructor(message: string);
+}
+/**
+ * Thrown when the Apimo API responds with a non-2xx HTTP status code.
+ *
+ * Prefer catching one of the more specific subclasses when you need to react
+ * differently per status code.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await api.fetchProperties(agencyId)
+ * } catch (e) {
+ *   if (e instanceof ApiHttpError) {
+ *     console.error(`HTTP ${e.statusCode}: ${e.message}`)
+ *   }
+ * }
+ * ```
+ */
+export declare class ApiHttpError extends ApimoError {
+    /** The HTTP status code returned by the API. */
+    readonly statusCode: number;
+    /** The URL that was requested. */
+    readonly url: string;
+    /** The raw response body, when it was possible to parse it. */
+    readonly responseBody?: unknown | undefined;
+    constructor(
+    /** The HTTP status code returned by the API. */
+    statusCode: number, 
+    /** The human-readable error message, sourced from the response body when available. */
+    message: string, 
+    /** The URL that was requested. */
+    url: string, 
+    /** The raw response body, when it was possible to parse it. */
+    responseBody?: unknown | undefined);
+}
+/**
+ * Thrown when the request is malformed (HTTP 400).
+ *
+ * This usually indicates a bug in the library or invalid arguments passed to a method.
+ */
+export declare class ApiBadRequestError extends ApiHttpError {
+    constructor(url: string, responseBody?: unknown);
+}
+/**
+ * Thrown when the provided credentials are invalid (HTTP 401).
+ *
+ * Verify that the `provider` and `token` passed to `new Apimo(...)` are correct.
+ */
+export declare class ApiUnauthorizedError extends ApiHttpError {
+    constructor(url: string, responseBody?: unknown);
+}
+/**
+ * Thrown when the authenticated user does not have access to the requested resource (HTTP 403).
+ *
+ * This can happen when trying to access an agency or property that belongs to a different provider.
+ */
+export declare class ApiForbiddenError extends ApiHttpError {
+    constructor(url: string, responseBody?: unknown);
+}
+/**
+ * Thrown when the requested resource does not exist (HTTP 404).
+ *
+ * Double-check the agency ID or any other identifiers you are passing.
+ */
+export declare class ApiNotFoundError extends ApiHttpError {
+    constructor(url: string, responseBody?: unknown);
+}
+/**
+ * Thrown when the API rate limit has been exceeded (HTTP 429).
+ *
+ * The built-in `Bottleneck` limiter normally prevents this, but it can still
+ * occur if multiple `Apimo` instances are running concurrently against the
+ * same credentials.
+ */
+export declare class ApiRateLimitError extends ApiHttpError {
+    constructor(url: string, responseBody?: unknown);
+}
+/**
+ * Thrown when the Apimo API returns a server-side error (HTTP 5xx).
+ *
+ * This indicates a problem on Apimo's infrastructure; retrying after a delay is usually appropriate.
+ */
+export declare class ApiServerError extends ApiHttpError {
+    constructor(statusCode: number, url: string, responseBody?: unknown);
+}
+/**
+ * Thrown when the response body does not match the expected schema.
+ *
+ * This most commonly happens when the Apimo API changes its response shape
+ * without notice. The `zodError` property contains the full Zod validation
+ * details to help you pinpoint the mismatch.
+ *
+ * @example
+ * ```ts
+ * } catch (e) {
+ *   if (e instanceof ApiResponseValidationError) {
+ *     console.error('Schema mismatch at', e.url)
+ *     console.error(e.zodError.format())
+ *   }
+ * }
+ * ```
+ */
+export declare class ApiResponseValidationError extends ApimoError {
+    /** The URL that was requested. */
+    readonly url: string;
+    /** The raw Zod error, containing detailed path/message information. */
+    readonly zodError: ZodError;
+    constructor(
+    /** The URL that was requested. */
+    url: string, 
+    /** The raw Zod error, containing detailed path/message information. */
+    zodError: ZodError);
+}
+/**
+ * Thrown when the `Apimo` instance is configured incorrectly before any
+ * network request is even made.
+ *
+ * @example
+ * ```ts
+ * } catch (e) {
+ *   if (e instanceof ApiConfigurationError) {
+ *     console.error('Fix your Apimo config:', e.message)
+ *   }
+ * }
+ * ```
+ */
+export declare class ApiConfigurationError extends ApimoError {
+    constructor(message: string);
+}
+/**
+ * Thrown when all retry attempts have been exhausted and the last attempt still
+ * failed. Inspect `cause` for the underlying error from the final attempt.
+ *
+ * @example
+ * ```ts
+ * } catch (e) {
+ *   if (e instanceof ApiRetryExhaustedError) {
+ *     console.error(`Gave up after ${e.attempts} attempt(s). Last error:`, e.cause)
+ *   }
+ * }
+ * ```
+ */
+export declare class ApiRetryExhaustedError extends ApimoError {
+    /** Total number of attempts made (including the first). */
+    readonly attempts: number;
+    /** The error thrown by the final attempt. */
+    readonly cause: unknown;
+    constructor(
+    /** Total number of attempts made (including the first). */
+    attempts: number, 
+    /** The error thrown by the final attempt. */
+    cause: unknown);
+}
+/**
+ * Returns `true` for errors that are safe to retry (transient failures).
+ * 429 and 5xx HTTP errors are retryable; 4xx errors (except 429) are not.
+ * Schema validation errors are never retried (same response will always fail).
+ * Non-HTTP errors (network failures, etc.) are considered retryable.
+ *
+ * @internal
+ */
+export declare function isRetryable(error: unknown): boolean;
+/**
+ * Maps an HTTP status code to the most specific `ApiHttpError` subclass and
+ * throws it.  Falls back to the generic `ApiHttpError` for unrecognised codes.
+ *
+ * @internal
+ */
+export declare function throwForStatus(statusCode: number, url: string, responseBody?: unknown): never;

package/dist/errors/index.js

@@ -0,0 +1,234 @@
+/**
+ * Base class for all Apimo errors.
+ * All errors thrown by the library extend this class, so you can catch them all with `catch (e) { if (e instanceof ApimoError) ... }`.
+ */
+export class ApimoError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+    }
+}
+// ---------------------------------------------------------------------------
+// HTTP / Network Errors
+// ---------------------------------------------------------------------------
+/**
+ * Thrown when the Apimo API responds with a non-2xx HTTP status code.
+ *
+ * Prefer catching one of the more specific subclasses when you need to react
+ * differently per status code.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await api.fetchProperties(agencyId)
+ * } catch (e) {
+ *   if (e instanceof ApiHttpError) {
+ *     console.error(`HTTP ${e.statusCode}: ${e.message}`)
+ *   }
+ * }
+ * ```
+ */
+export class ApiHttpError extends ApimoError {
+    constructor(
+    /** The HTTP status code returned by the API. */
+    statusCode, 
+    /** The human-readable error message, sourced from the response body when available. */
+    message, 
+    /** The URL that was requested. */
+    url, 
+    /** The raw response body, when it was possible to parse it. */
+    responseBody) {
+        super(message);
+        this.statusCode = statusCode;
+        this.url = url;
+        this.responseBody = responseBody;
+    }
+}
+/**
+ * Thrown when the request is malformed (HTTP 400).
+ *
+ * This usually indicates a bug in the library or invalid arguments passed to a method.
+ */
+export class ApiBadRequestError extends ApiHttpError {
+    constructor(url, responseBody) {
+        super(400, 'Bad request: the server could not understand the request. Check that all parameters are valid.', url, responseBody);
+    }
+}
+/**
+ * Thrown when the provided credentials are invalid (HTTP 401).
+ *
+ * Verify that the `provider` and `token` passed to `new Apimo(...)` are correct.
+ */
+export class ApiUnauthorizedError extends ApiHttpError {
+    constructor(url, responseBody) {
+        super(401, 'Unauthorized: invalid credentials. Verify your provider ID and token.', url, responseBody);
+    }
+}
+/**
+ * Thrown when the authenticated user does not have access to the requested resource (HTTP 403).
+ *
+ * This can happen when trying to access an agency or property that belongs to a different provider.
+ */
+export class ApiForbiddenError extends ApiHttpError {
+    constructor(url, responseBody) {
+        super(403, 'Forbidden: you do not have permission to access this resource.', url, responseBody);
+    }
+}
+/**
+ * Thrown when the requested resource does not exist (HTTP 404).
+ *
+ * Double-check the agency ID or any other identifiers you are passing.
+ */
+export class ApiNotFoundError extends ApiHttpError {
+    constructor(url, responseBody) {
+        super(404, 'Not found: the requested resource does not exist.', url, responseBody);
+    }
+}
+/**
+ * Thrown when the API rate limit has been exceeded (HTTP 429).
+ *
+ * The built-in `Bottleneck` limiter normally prevents this, but it can still
+ * occur if multiple `Apimo` instances are running concurrently against the
+ * same credentials.
+ */
+export class ApiRateLimitError extends ApiHttpError {
+    constructor(url, responseBody) {
+        super(429, 'Rate limit exceeded: too many requests. Slow down and retry after a moment. You may have hit your daily limit.', url, responseBody);
+    }
+}
+/**
+ * Thrown when the Apimo API returns a server-side error (HTTP 5xx).
+ *
+ * This indicates a problem on Apimo's infrastructure; retrying after a delay is usually appropriate.
+ */
+export class ApiServerError extends ApiHttpError {
+    constructor(statusCode, url, responseBody) {
+        super(statusCode, `Server error (${statusCode}): the Apimo API encountered an internal error. Try again later.`, url, responseBody);
+    }
+}
+// ---------------------------------------------------------------------------
+// Schema / Validation Errors
+// ---------------------------------------------------------------------------
+/**
+ * Thrown when the response body does not match the expected schema.
+ *
+ * This most commonly happens when the Apimo API changes its response shape
+ * without notice. The `zodError` property contains the full Zod validation
+ * details to help you pinpoint the mismatch.
+ *
+ * @example
+ * ```ts
+ * } catch (e) {
+ *   if (e instanceof ApiResponseValidationError) {
+ *     console.error('Schema mismatch at', e.url)
+ *     console.error(e.zodError.format())
+ *   }
+ * }
+ * ```
+ */
+export class ApiResponseValidationError extends ApimoError {
+    constructor(
+    /** The URL that was requested. */
+    url, 
+    /** The raw Zod error, containing detailed path/message information. */
+    zodError) {
+        var _a, _b;
+        // Zod v4 uses `issues`; fall back to `errors` for Zod v3 compatibility.
+        const issues = (_b = (_a = zodError.issues) !== null && _a !== void 0 ? _a : zodError.errors) !== null && _b !== void 0 ? _b : [];
+        super(`Response validation failed for ${url}:\n${issues
+            .map(e => `  - [${e.path.join('.')}] ${e.message}`)
+            .join('\n')}`);
+        this.url = url;
+        this.zodError = zodError;
+    }
+}
+// ---------------------------------------------------------------------------
+// Configuration Errors
+// ---------------------------------------------------------------------------
+/**
+ * Thrown when the `Apimo` instance is configured incorrectly before any
+ * network request is even made.
+ *
+ * @example
+ * ```ts
+ * } catch (e) {
+ *   if (e instanceof ApiConfigurationError) {
+ *     console.error('Fix your Apimo config:', e.message)
+ *   }
+ * }
+ * ```
+ */
+export class ApiConfigurationError extends ApimoError {
+    constructor(message) {
+        super(`Configuration error: ${message}`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Retry Errors
+// ---------------------------------------------------------------------------
+/**
+ * Thrown when all retry attempts have been exhausted and the last attempt still
+ * failed. Inspect `cause` for the underlying error from the final attempt.
+ *
+ * @example
+ * ```ts
+ * } catch (e) {
+ *   if (e instanceof ApiRetryExhaustedError) {
+ *     console.error(`Gave up after ${e.attempts} attempt(s). Last error:`, e.cause)
+ *   }
+ * }
+ * ```
+ */
+export class ApiRetryExhaustedError extends ApimoError {
+    constructor(
+    /** Total number of attempts made (including the first). */
+    attempts, 
+    /** The error thrown by the final attempt. */
+    cause) {
+        super(`Request failed after ${attempts} attempt${attempts === 1 ? '' : 's'}. Last error: ${cause instanceof Error ? cause.message : String(cause)}`);
+        this.attempts = attempts;
+        this.cause = cause;
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Returns `true` for errors that are safe to retry (transient failures).
+ * 429 and 5xx HTTP errors are retryable; 4xx errors (except 429) are not.
+ * Schema validation errors are never retried (same response will always fail).
+ * Non-HTTP errors (network failures, etc.) are considered retryable.
+ *
+ * @internal
+ */
+export function isRetryable(error) {
+    // Schema validation failures are deterministic — retrying will not help
+    if (error instanceof ApiResponseValidationError) {
+        return false;
+    }
+    if (error instanceof ApiHttpError) {
+        return error.statusCode === 429 || error.statusCode >= 500;
+    }
+    // Network errors, timeouts, etc.
+    return true;
+}
+/**
+ * Maps an HTTP status code to the most specific `ApiHttpError` subclass and
+ * throws it.  Falls back to the generic `ApiHttpError` for unrecognised codes.
+ *
+ * @internal
+ */
+export function throwForStatus(statusCode, url, responseBody) {
+    switch (statusCode) {
+        case 400: throw new ApiBadRequestError(url, responseBody);
+        case 401: throw new ApiUnauthorizedError(url, responseBody);
+        case 403: throw new ApiForbiddenError(url, responseBody);
+        case 404: throw new ApiNotFoundError(url, responseBody);
+        case 429: throw new ApiRateLimitError(url, responseBody);
+        default:
+            if (statusCode >= 500) {
+                throw new ApiServerError(statusCode, url, responseBody);
+            }
+            throw new ApiHttpError(statusCode, `HTTP error ${statusCode}`, url, responseBody);
+    }
+}

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export type { CatalogName } from './consts/catalogs';
 export type { ApiCulture } from './consts/languages';
 export { type AdditionalConfig, Apimo, DEFAULT_ADDITIONAL_CONFIG, DEFAULT_BASE_URL } from './core/api';
 export { Apimo as Api } from './core/api';
+export { ApiBadRequestError, ApiConfigurationError, ApiForbiddenError, ApiHttpError, ApimoError, ApiNotFoundError, ApiRateLimitError, ApiResponseValidationError, ApiRetryExhaustedError, ApiServerError, ApiUnauthorizedError, } from './errors';
 export type { ApimoAgency, ApimoPartner, ApimoRate } from './schemas/agency';
 export type { ApimoCity, ApimoUser, CatalogDefinition, CatalogEntry, CatalogTransformer, LocalizedCatalogTransformer, } from './schemas/common';
 export type { ApimoAgreement, ApimoArea, ApimoComment, ApimoConstruction, ApimoFloor, ApimoHeating, ApimoPicture, ApimoPlot, ApimoPrice, ApimoProperty, ApimoRegulation, ApimoResidence, ApimoSurface, ApimoView, ApimoWater, } from './schemas/property';