@povio/openapi-codegen-cli 2.0.8-rc.9 → 2.0.8

package/dist/lib/auth/auth.context.d.ts

@@ -0,0 +1,22 @@
+import { PropsWithChildren, ReactNode } from 'react';
+export declare namespace AuthContext {
+    export interface Routes {
+        authenticated?: string;
+        unauthenticated?: string;
+    }
+    interface Type<TUser = unknown> {
+        isAuthenticated: boolean;
+        isInitializing: boolean;
+        logout: () => void;
+        updateTokens?: (accessToken: string | null, refreshToken?: string | null) => void;
+        accessToken?: string | null;
+        user?: TUser | null;
+        userPromise?: () => Promise<TUser | null>;
+        routes?: Routes;
+        loadingState?: ReactNode;
+    }
+    type ProviderProps<TUser = unknown> = Type<TUser>;
+    export const Provider: <TUser>({ isAuthenticated, isInitializing, logout, updateTokens, accessToken, user, userPromise, routes, loadingState, children, }: PropsWithChildren<ProviderProps<TUser>>) => import("react/jsx-runtime").JSX.Element;
+    export const useAuth: <TUser>() => Type<TUser>;
+    export {};
+}

package/dist/lib/auth/auth.context.mjs

@@ -0,0 +1,41 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, useMemo, use } from "react";
+var AuthContext;
+((AuthContext2) => {
+  const Context = createContext({});
+  AuthContext2.Provider = ({
+    isAuthenticated,
+    isInitializing,
+    logout,
+    updateTokens,
+    accessToken,
+    user,
+    userPromise,
+    routes,
+    loadingState,
+    children
+  }) => {
+    const value = useMemo(
+      () => ({
+        isAuthenticated,
+        isInitializing,
+        logout,
+        updateTokens,
+        accessToken,
+        user,
+        userPromise,
+        routes,
+        loadingState
+      }),
+      [isAuthenticated, isInitializing, logout, updateTokens, accessToken, user, userPromise, routes, loadingState]
+    );
+    return /* @__PURE__ */ jsx(Context.Provider, { value, children });
+  };
+  AuthContext2.useAuth = () => {
+    const auth = use(Context);
+    return auth;
+  };
+})(AuthContext || (AuthContext = {}));
+export {
+  AuthContext
+};

package/dist/lib/config/i18n.d.ts

@@ -0,0 +1,32 @@
+export declare const ns = "openapi";
+export declare const resources: {
+    readonly en: {
+        readonly openapi: {
+            openapi: {
+                sharedErrors: {
+                    dataValidation: string;
+                    internalError: string;
+                    networkError: string;
+                    canceledError: string;
+                    unknownError: string;
+                    unknownErrorWithCode: string;
+                };
+            };
+        };
+    };
+    readonly sl: {
+        readonly openapi: {
+            openapi: {
+                sharedErrors: {
+                    dataValidation: string;
+                    internalError: string;
+                    networkError: string;
+                    canceledError: string;
+                    unknownError: string;
+                    unknownErrorWithCode: string;
+                };
+            };
+        };
+    };
+};
+export declare const defaultT: import('i18next').TFunction<["translation", ...string[]], undefined>;

package/dist/lib/config/i18n.mjs

@@ -0,0 +1,31 @@
+import i18next from "i18next";
+import translationEN from "../assets/locales/en/translation.json.mjs";
+import translationSL from "../assets/locales/sl/translation.json.mjs";
+const ns = "openapi";
+const resources = {
+  en: {
+    [ns]: translationEN
+  },
+  sl: {
+    [ns]: translationSL
+  }
+};
+const defaultLanguage = "en";
+const i18n = i18next.createInstance();
+i18n.init({
+  compatibilityJSON: "v4",
+  lng: defaultLanguage,
+  fallbackLng: defaultLanguage,
+  resources,
+  ns: Object.keys(resources.en),
+  defaultNS: ns,
+  interpolation: {
+    escapeValue: false
+  }
+});
+const defaultT = i18n.t.bind(i18n);
+export {
+  defaultT,
+  ns,
+  resources
+};

package/dist/lib/config/queryConfig.context.d.ts

@@ -0,0 +1,17 @@
+import { PropsWithChildren } from 'react';
+import { QueryKey } from '@tanstack/react-query';
+export type QueryModule = string | number | symbol;
+export type InvalidationMapFunc<TData = any, TVariables = any> = (data: TData, variables: TVariables) => QueryKey[];
+export type InvalidationMap<TData = any, TVariables = any> = Record<QueryModule, InvalidationMapFunc<TData, TVariables>>;
+export declare namespace OpenApiQueryConfig {
+    interface Type {
+        preferUpdate?: boolean;
+        invalidateCurrentModule?: boolean;
+        invalidationMap?: InvalidationMap;
+        crossTabInvalidation?: boolean;
+    }
+    type ProviderProps = Type;
+    export const Provider: ({ preferUpdate, invalidateCurrentModule, invalidationMap, crossTabInvalidation, children, }: PropsWithChildren<ProviderProps>) => import("react/jsx-runtime").JSX.Element;
+    export const useConfig: () => Type;
+    export {};
+}

package/dist/lib/config/queryConfig.context.mjs

@@ -0,0 +1,26 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, useMemo, use } from "react";
+var OpenApiQueryConfig;
+((OpenApiQueryConfig2) => {
+  const Context = createContext({});
+  OpenApiQueryConfig2.Provider = ({
+    preferUpdate,
+    invalidateCurrentModule,
+    invalidationMap,
+    crossTabInvalidation,
+    children
+  }) => {
+    const value = useMemo(
+      () => ({ preferUpdate, invalidateCurrentModule, invalidationMap, crossTabInvalidation }),
+      [preferUpdate, invalidateCurrentModule, invalidationMap, crossTabInvalidation]
+    );
+    return /* @__PURE__ */ jsx(Context.Provider, { value, children });
+  };
+  OpenApiQueryConfig2.useConfig = () => {
+    const context = use(Context);
+    return context ?? {};
+  };
+})(OpenApiQueryConfig || (OpenApiQueryConfig = {}));
+export {
+  OpenApiQueryConfig
+};

package/dist/lib/config/router.context.d.ts

@@ -0,0 +1,9 @@
+import { PropsWithChildren } from 'react';
+interface RouterProviderProps {
+    replace: (url: string) => void;
+}
+export declare namespace OpenApiRouter {
+    const Provider: ({ children, replace }: PropsWithChildren<RouterProviderProps>) => import("react/jsx-runtime").JSX.Element;
+    const useRouter: () => RouterProviderProps;
+}
+export {};

package/dist/lib/config/router.context.mjs

@@ -0,0 +1,20 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, useMemo, use } from "react";
+var OpenApiRouter;
+((OpenApiRouter2) => {
+  const Context = createContext(null);
+  OpenApiRouter2.Provider = ({ children, replace }) => {
+    const value = useMemo(() => ({ replace }), [replace]);
+    return /* @__PURE__ */ jsx(Context, { value, children });
+  };
+  OpenApiRouter2.useRouter = () => {
+    const context = use(Context);
+    if (!context) {
+      throw new Error("useRouter must be used within an OpenApiRouter.Provider");
+    }
+    return context;
+  };
+})(OpenApiRouter || (OpenApiRouter = {}));
+export {
+  OpenApiRouter
+};

package/dist/lib/react-query.types.d.ts

@@ -0,0 +1,10 @@
+import { InfiniteData, QueryKey, UseInfiniteQueryOptions, UseMutationOptions, UseQueryOptions } from '@tanstack/react-query';
+import { ApplicationException, GeneralErrorCodes } from './rest/error-handling';
+type Function = (...args: any) => any;
+type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
+type IsAny<T> = IfAny<T, true, never>;
+type IsUnknown<T, Y, N = T> = IsAny<T> extends never ? (unknown extends T ? Y : N) : N;
+export type AppQueryOptions<TFunction extends Function, TData = Awaited<ReturnType<TFunction>>, TErrorCodes = GeneralErrorCodes> = Omit<UseQueryOptions<Awaited<ReturnType<TFunction>>, ApplicationException<TErrorCodes>, IsUnknown<TData, Awaited<ReturnType<TFunction>>>>, "queryKey" | "queryFn">;
+export type AppMutationOptions<TFunction extends Function, TVariables = void, TData = Awaited<ReturnType<TFunction>>, TErrorCodes = GeneralErrorCodes> = Omit<UseMutationOptions<TData, ApplicationException<TErrorCodes>, TVariables>, "mutationKey" | "mutationFn">;
+export type AppInfiniteQueryOptions<TFunction extends Function, TData = InfiniteData<Awaited<ReturnType<TFunction>>>, TErrorCodes = GeneralErrorCodes, TQueryKey extends QueryKey = QueryKey, TPageParam = number> = Omit<UseInfiniteQueryOptions<Awaited<ReturnType<TFunction>>, ApplicationException<TErrorCodes>, IsUnknown<TData, InfiniteData<Awaited<ReturnType<TFunction>>>>, TQueryKey, TPageParam>, "queryKey" | "queryFn" | "initialPageParam" | "getNextPageParam">;
+export {};

package/dist/lib/rest/error-handling.d.ts

@@ -0,0 +1,30 @@
+import { TFunction } from 'i18next';
+export type GeneralErrorCodes = "DATA_VALIDATION_ERROR" | "NETWORK_ERROR" | "CANCELED_ERROR" | "INTERNAL_ERROR" | "UNKNOWN_ERROR";
+export declare class ApplicationException<CodeT> extends Error {
+    code: CodeT;
+    serverMessage: string | null;
+    constructor(message: string, code: CodeT, serverMessage: string | null);
+}
+export interface ErrorEntry<CodeT> {
+    code: CodeT;
+    condition?: (error: unknown) => boolean;
+    getMessage: (t: TFunction<string, undefined>, error: unknown) => string;
+}
+export interface ErrorHandlerOptions<CodeT extends string> {
+    entries: ErrorEntry<CodeT>[];
+    t?: TFunction<string, undefined>;
+    onRethrowError?: (error: unknown, exception: ApplicationException<CodeT | GeneralErrorCodes>) => void;
+}
+export declare class ErrorHandler<CodeT extends string> {
+    entries: ErrorEntry<CodeT | GeneralErrorCodes>[];
+    private t;
+    private onRethrowError?;
+    constructor({ entries, t, onRethrowError }: ErrorHandlerOptions<CodeT>);
+    private matchesEntry;
+    setTranslateFunction(t: TFunction<string, undefined>): void;
+    rethrowError(error: unknown): ApplicationException<CodeT | GeneralErrorCodes>;
+    getError(error: unknown): ApplicationException<CodeT | GeneralErrorCodes> | null;
+    getErrorCode(error: unknown): CodeT | GeneralErrorCodes | null;
+    static getErrorMessage(error: unknown, fallbackToUnknown?: boolean): string | null;
+}
+export declare const SharedErrorHandler: ErrorHandler<never>;

package/dist/lib/rest/error-handling.mjs

@@ -0,0 +1,132 @@
+import { isAxiosError, isCancel } from "axios";
+import { z } from "zod";
+import { defaultT } from "../config/i18n.mjs";
+import { RestUtils } from "./rest.utils.mjs";
+class ApplicationException extends Error {
+  code;
+  serverMessage = null;
+  constructor(message, code, serverMessage) {
+    super(message);
+    this.code = code;
+    this.serverMessage = serverMessage;
+  }
+}
+class ErrorHandler {
+  entries = [];
+  t;
+  onRethrowError;
+  constructor({ entries, t = defaultT, onRethrowError }) {
+    this.t = t;
+    this.onRethrowError = onRethrowError;
+    const dataValidationError = {
+      code: "DATA_VALIDATION_ERROR",
+      condition: (e) => {
+        return e instanceof z.ZodError;
+      },
+      getMessage: () => this.t("openapi.sharedErrors.dataValidation")
+    };
+    const internalError = {
+      code: "INTERNAL_ERROR",
+      condition: (e) => {
+        if (isAxiosError(e)) {
+          return e.response?.status != null && e.response.status >= 500 && e.response.status < 600;
+        }
+        return false;
+      },
+      getMessage: () => this.t("openapi.sharedErrors.internalError")
+    };
+    const networkError = {
+      code: "NETWORK_ERROR",
+      condition: (e) => {
+        if (isAxiosError(e)) {
+          return e.code === "ERR_NETWORK";
+        }
+        return false;
+      },
+      getMessage: () => this.t("openapi.sharedErrors.networkError")
+    };
+    const canceledError = {
+      code: "CANCELED_ERROR",
+      condition: (e) => {
+        if (isCancel(e)) {
+          return true;
+        }
+        if (isAxiosError(e) && e.code === "ECONNABORTED") {
+          return true;
+        }
+        return false;
+      },
+      getMessage: () => this.t("openapi.sharedErrors.canceledError")
+    };
+    const unknownError = {
+      code: "UNKNOWN_ERROR",
+      condition: () => true,
+      getMessage: (_, e) => {
+        const code = RestUtils.extractServerResponseCode(e);
+        const serverMessage = RestUtils.extractServerErrorMessage(e);
+        if (code) {
+          let message = `Unknown error, message from server: ${code}`;
+          if (serverMessage) {
+            message += ` ${serverMessage}`;
+          }
+          return message;
+        }
+        return this.t("openapi.sharedErrors.unknownError");
+      }
+    };
+    this.entries = [...entries, dataValidationError, internalError, networkError, canceledError, unknownError];
+  }
+  matchesEntry(error, entry, code) {
+    if (entry.condition) {
+      return entry.condition(error);
+    }
+    return code === entry.code;
+  }
+  setTranslateFunction(t) {
+    this.t = t;
+  }
+  rethrowError(error) {
+    const code = RestUtils.extractServerResponseCode(error);
+    const errorEntry = this.entries.find((entry) => this.matchesEntry(error, entry, code));
+    const serverMessage = RestUtils.extractServerErrorMessage(error);
+    const exception = new ApplicationException(errorEntry.getMessage(this.t, error), errorEntry.code, serverMessage);
+    this.onRethrowError?.(error, exception);
+    throw exception;
+  }
+  getError(error) {
+    if (error instanceof ApplicationException) {
+      return error;
+    }
+    return null;
+  }
+  getErrorCode(error) {
+    if (error instanceof ApplicationException) {
+      return error.code;
+    }
+    return null;
+  }
+  static getErrorMessage(error, fallbackToUnknown = true) {
+    if (typeof error === "string") {
+      return error;
+    }
+    if (error instanceof Error) {
+      return error.message;
+    }
+    if (error instanceof ApplicationException) {
+      if (error.serverMessage != null) {
+        return error.serverMessage;
+      }
+      return error.message;
+    }
+    if (fallbackToUnknown) {
+      return defaultT("openapi.sharedErrors.unknownError");
+    }
+    return null;
+  }
+}
+const SharedErrorHandler = new ErrorHandler({ entries: [] });
+export {
+  ApplicationException,
+  ErrorHandler,
+  SharedErrorHandler
+};

package/dist/lib/rest/rest-client.d.ts

@@ -0,0 +1,22 @@
+import { AxiosRequestConfig, CreateAxiosDefaults } from 'axios';
+import { ErrorHandler, GeneralErrorCodes } from './error-handling';
+import { RestClient as IRestClient, RequestConfig, RequestInfo, Response } from './rest-client.types';
+import { RestInterceptor } from './rest-interceptor';
+export declare class RestClient implements IRestClient {
+    private readonly client;
+    private readonly errorHandler;
+    constructor({ config, interceptors, errorHandler, }?: {
+        config?: CreateAxiosDefaults;
+        interceptors?: RestInterceptor<any[]>[];
+        errorHandler?: ErrorHandler<any>;
+    });
+    attachInterceptors<T extends any[]>(interceptors?: RestInterceptor<T>[], ...args: T): void;
+    attachInterceptor<T extends any[]>(interceptor: RestInterceptor<T>, ...args: T): void;
+    ejectInterceptor<T extends any[]>(interceptor: RestInterceptor<T>): void;
+    get<ZOutput, ECodes extends string = GeneralErrorCodes, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+    post<ZOutput, ECodes extends string = GeneralErrorCodes, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: any, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+    patch<ZOutput, ECodes extends string = GeneralErrorCodes, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: any, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+    put<ZOutput, ECodes extends string = GeneralErrorCodes, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: any, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+    delete<ZOutput, ECodes extends string = GeneralErrorCodes, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: any, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+    private makeRequest;
+}

package/dist/lib/rest/rest-client.mjs

@@ -0,0 +1,62 @@
+import axios from "axios";
+import { z } from "zod";
+import { SharedErrorHandler } from "./error-handling.mjs";
+class RestClient {
+  client;
+  errorHandler;
+  constructor({
+    config,
+    interceptors,
+    errorHandler
+  } = {}) {
+    this.client = axios.create(config);
+    this.errorHandler = errorHandler ?? SharedErrorHandler;
+    this.attachInterceptors(interceptors);
+  }
+  attachInterceptors(interceptors, ...args) {
+    if (interceptors != null) {
+      interceptors.forEach((interceptor) => this.attachInterceptor(interceptor, ...args));
+    }
+  }
+  attachInterceptor(interceptor, ...args) {
+    interceptor.addInterceptor(this.client, ...args);
+  }
+  ejectInterceptor(interceptor) {
+    interceptor.removeInterceptor(this.client);
+  }
+  async get(requestInfo, url, requestConfig) {
+    return this.makeRequest(requestInfo, { ...requestConfig, method: "get", url });
+  }
+  async post(requestInfo, url, data, requestConfig) {
+    return this.makeRequest(requestInfo, { ...requestConfig, method: "post", url, data });
+  }
+  async patch(requestInfo, url, data, requestConfig) {
+    return this.makeRequest(requestInfo, { ...requestConfig, method: "patch", url, data });
+  }
+  async put(requestInfo, url, data, requestConfig) {
+    return this.makeRequest(requestInfo, { ...requestConfig, method: "put", url, data });
+  }
+  async delete(requestInfo, url, data, requestConfig) {
+    return this.makeRequest(requestInfo, { ...requestConfig, method: "delete", url, data });
+  }
+  async makeRequest(requestInfo, requestConfig) {
+    const errorStack = new Error().stack;
+    try {
+      const { rawResponse, ...config } = requestConfig;
+      const res = await this.client(config);
+      const resData = requestInfo.resSchema.parse(res.data);
+      return rawResponse ? { ...res, data: resData } : resData;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        error.name = "BE Response schema mismatch - ZodError";
+        error.stack = [error.stack, ...errorStack?.split("\n").slice(2) ?? []].join("\n");
+      }
+      const errorHandler = requestInfo.errorHandler ?? this.errorHandler;
+      errorHandler.rethrowError(error);
+      throw error;
+    }
+  }
+}
+export {
+  RestClient
+};

package/dist/lib/rest/rest-client.types.d.ts

@@ -0,0 +1,23 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+import { z } from 'zod';
+import { ErrorHandler } from './error-handling';
+import { RestInterceptor } from './rest-interceptor';
+export type GeneralErrorCodes = string;
+export interface RequestInfo<ZOutput, ECodes extends string> {
+    resSchema: z.ZodType<ZOutput>;
+    errorHandler?: ErrorHandler<ECodes>;
+}
+export interface RequestConfig<IsRawRes extends boolean = false> {
+    rawResponse?: IsRawRes;
+}
+export type Response<ZOutput, IsRawRes extends boolean = false> = IsRawRes extends true ? AxiosResponse<ZOutput> : ZOutput;
+export interface RestClient {
+    attachInterceptors<T extends any[]>(interceptors?: RestInterceptor<T>[], ...args: T): void;
+    attachInterceptor<T extends any[]>(interceptor: RestInterceptor<T>, ...args: T): void;
+    ejectInterceptor<T extends any[]>(interceptor: RestInterceptor<T>): void;
+    get<ZOutput, ECodes extends string = GeneralErrorCodes, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+    post<ZOutput, ECodes extends string = GeneralErrorCodes, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: any, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+    patch<ZOutput, ECodes extends string = GeneralErrorCodes, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: any, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+    put<ZOutput, ECodes extends string = GeneralErrorCodes, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: any, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+    delete<ZOutput, ECodes extends string = GeneralErrorCodes, IsRawRes extends boolean = false>(requestInfo: RequestInfo<ZOutput, ECodes>, url: string, data?: any, requestConfig?: AxiosRequestConfig & RequestConfig<IsRawRes>): Promise<Response<ZOutput, IsRawRes>>;
+}

package/dist/lib/rest/rest-interceptor.d.ts

@@ -0,0 +1,8 @@
+import { AxiosInstance } from 'axios';
+export declare class RestInterceptor<T extends any[]> {
+    private applyInterceptor;
+    private interceptorIdMap;
+    constructor(applyInterceptor: (client: AxiosInstance, ...args: T) => number);
+    addInterceptor(client: AxiosInstance, ...args: T): void;
+    removeInterceptor(client: AxiosInstance): void;
+}

package/dist/lib/rest/rest-interceptor.mjs

@@ -0,0 +1,21 @@
+class RestInterceptor {
+  constructor(applyInterceptor) {
+    this.applyInterceptor = applyInterceptor;
+  }
+  interceptorIdMap = [];
+  addInterceptor(client, ...args) {
+    this.removeInterceptor(client);
+    const interceptorId = this.applyInterceptor(client, ...args);
+    this.interceptorIdMap.push({ client, interceptorId });
+  }
+  removeInterceptor(client) {
+    const interceptorId = this.interceptorIdMap.find((i) => i.client === client)?.interceptorId;
+    if (interceptorId != null) {
+      client.interceptors.request.eject(interceptorId);
+      this.interceptorIdMap = this.interceptorIdMap.filter((i) => i.client !== client);
+    }
+  }
+}
+export {
+  RestInterceptor
+};

package/dist/lib/rest/rest.utils.d.ts

@@ -0,0 +1,7 @@
+import { AxiosError, AxiosResponseHeaders } from 'axios';
+export declare namespace RestUtils {
+    const extractServerResponseCode: (e: unknown) => string | null;
+    const doesServerErrorMessageContain: (e: AxiosError, text: string) => boolean;
+    const extractServerErrorMessage: (e: unknown) => string | null;
+    const extractContentDispositionFilename: (headers: AxiosResponseHeaders) => string | undefined;
+}

package/dist/lib/rest/rest.utils.mjs

@@ -0,0 +1,51 @@
+import { isAxiosError } from "axios";
+import { z } from "zod";
+var RestUtils;
+((RestUtils2) => {
+  RestUtils2.extractServerResponseCode = (e) => {
+    if (e instanceof z.ZodError) {
+      return "validation-exception";
+    }
+    if (!isAxiosError(e)) {
+      return null;
+    }
+    if (!e.response) {
+      return null;
+    }
+    const data = e.response.data;
+    if (typeof data?.code === "string") {
+      return data.code;
+    }
+    return null;
+  };
+  RestUtils2.doesServerErrorMessageContain = (e, text) => {
+    const message = (0, RestUtils2.extractServerErrorMessage)(e);
+    if (message === null || message === void 0) {
+      return false;
+    }
+    return message.toLowerCase().includes(text.toLowerCase());
+  };
+  RestUtils2.extractServerErrorMessage = (e) => {
+    if (e instanceof z.ZodError) {
+      return e.message;
+    }
+    if (!isAxiosError(e)) {
+      return null;
+    }
+    if (!e.response) {
+      return null;
+    }
+    const data = e.response.data;
+    if (typeof data?.message === "string") {
+      return data.message;
+    }
+    return null;
+  };
+  RestUtils2.extractContentDispositionFilename = (headers) => {
+    const contentDisposition = headers["content-disposition"];
+    return contentDisposition ? /filename=["']?([^"';]+)/i.exec(contentDisposition)?.[1] : void 0;
+  };
+})(RestUtils || (RestUtils = {}));
+export {
+  RestUtils
+};

package/dist/sh.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};