@povio/openapi-codegen-cli 2.0.8-rc.37 → 2.0.8-rc.39

package/dist/generators/utils/ts.utils.d.ts

@@ -0,0 +1,16 @@
+import { OpenAPIV3 } from 'openapi-types';
+import { SchemaResolver } from '../core/SchemaResolver.class';
+import { TsMetaType, TsTypeBase } from '../types/metadata';
+import { PrimitiveType } from '../types/openapi';
+export declare function primitiveTypeToTsType(type: PrimitiveType): string;
+export declare function getTsTypeBase({ zodSchemaName, schema, resolver, }: {
+    zodSchemaName?: string;
+    schema?: OpenAPIV3.SchemaObject;
+    resolver: SchemaResolver;
+}): TsTypeBase;
+export declare function getSchemaTsMetaType({ schema, isCircular, parentTypes, resolver, }: {
+    schema?: OpenAPIV3.SchemaObject;
+    isCircular?: boolean;
+    parentTypes: TsTypeBase[];
+    resolver: SchemaResolver;
+}): TsMetaType;

package/dist/generators/utils/validation.utils.d.ts

@@ -0,0 +1,17 @@
+import { HttpStatusCode } from '../const/validation.const';
+import { Endpoint, EndpointParameter } from '../types/endpoint';
+import { OperationObject } from '../types/openapi';
+import { ValidationError, ValidationErrorType } from '../types/validation';
+export declare function getInvalidSchemaError(message: string): ValidationError;
+export declare function getInvalidOperationIdError(operationId: string): ValidationError;
+export declare function getMissingPathParameterError(params: EndpointParameter[], path: string): ValidationError;
+export declare function getNotAllowedInlineEnumError(enumProperty: string): ValidationError;
+export declare function getNotAllowedCircularSchemaError(message: string): ValidationError;
+export declare function getMissingAclConditionPropertyError(propertyName: string, operation: OperationObject, endpoint: Endpoint): ValidationError;
+export declare function getMissingStatusCodeError(statusCode: HttpStatusCode, operation: OperationObject, endpoint: Endpoint): ValidationError;
+export declare function getInvalidStatusCodeError(statusCode: {
+    expected: HttpStatusCode;
+    received: HttpStatusCode;
+}, operation: OperationObject, endpoint: Endpoint): ValidationError;
+export declare function getMultipleSuccessStatusCodesError(statusCodes: HttpStatusCode[], operation: OperationObject, endpoint: Endpoint): ValidationError;
+export declare function groupByType(validationErrors: ValidationError[]): Record<ValidationErrorType, string[]>;

package/dist/generators/utils/zod-schema.utils.d.ts

@@ -0,0 +1,15 @@
+export declare const getZodSchemaName: (name: string, schemaSuffix: string) => string;
+export declare const getEnumZodSchemaName: (name: string, enumSuffix: string, schemaSuffix: string) => string;
+export declare const isNamedZodSchema: (schema: string) => boolean;
+export declare const isEnumZodSchema: (schema: string) => boolean;
+export declare const getZodSchemaOperationName: (operationName: string, isUniqueOperationName: boolean, tag: string) => string;
+export declare const getBodyZodSchemaName: (operationName: string) => string;
+export declare const getParamZodSchemaName: (operationName: string, paramName: string) => string;
+export declare const getMainResponseZodSchemaName: (operationName: string) => string;
+export declare const getErrorResponseZodSchemaName: (operationName: string, statusCode: string) => string;
+export declare function getResponseZodSchemaName({ statusCode, operationName, isUniqueOperationName, tag, }: {
+    statusCode: string;
+    operationName: string;
+    isUniqueOperationName: boolean;
+    tag: string;
+}): string;

package/dist/helpers/cli.helper.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Print a variable, color it magenta if it's different from the default
+ * @param name
+ * @param value
+ * @param defaultValue
+ */
+export declare function logVariable(name: string, value: any, defaultValue?: string | number): void;
+export declare function log(message: string): void;
+export declare function logInfo(message: string): void;
+export declare function logNotice(message: string): void;
+export declare function logSuccess(message: string): void;
+export declare function logWarning(message: string): void;
+export declare function logError(error: Error | string, message?: string): void;
+export declare function logBanner(message: string): void;
+/**
+ * Request a ENV variable from the user if not set
+ * @param name
+ * @param value
+ * @param suggested - the value the scripts expects and suggest
+ */
+export declare function promptVar(name: string, value: string, suggested?: string): Promise<string>;
+export declare function confirm(message: string): Promise<boolean>;

package/dist/helpers/config.helper.d.ts

@@ -0,0 +1,3 @@
+import { OpenAPICodegenConfig } from '../generators/types/config';
+export declare function loadConfig(configPath?: string): Promise<OpenAPICodegenConfig | null>;
+export declare const loadJsSync: (filepath: string) => unknown;

package/dist/helpers/version.helper.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Fetch the version from package.json
+ */
+export declare function getVersion(): string | undefined;

package/dist/helpers/yargs.helper.d.ts

@@ -0,0 +1,10 @@
+import { Options } from 'yargs';
+interface IOptionProperties extends Options {
+    envAlias?: string;
+}
+export declare function YargOption(properties: IOptionProperties): (target: object, propertyKey: string) => void;
+export declare function getYargsOption<T>(target: any): Record<keyof T, IOptionProperties>;
+export declare function getBuilder(options: any): (y: any) => Promise<any>;
+export declare function getYargsOptions<T>(target: any): Record<keyof T, Options>;
+export declare function loadYargsConfig<T>(cls: new () => T, _argv: Record<string, unknown>): Promise<T>;
+export {};

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export * from './generators/types/config';
+export { RestClient } from './lib/rest/rest-client';
+export type { RequestInfo, RequestConfig, Response, RestClient as IRestClient } from './lib/rest/rest-client.types';
+export { RestInterceptor } from './lib/rest/rest-interceptor';
+export { RestUtils } from './lib/rest/rest.utils';
+export { ApplicationException, ErrorHandler, SharedErrorHandler } from './lib/rest/error-handling';
+export type { GeneralErrorCodes, ErrorHandlerOptions, ErrorEntry } from './lib/rest/error-handling';
+export type { AppQueryOptions, AppMutationOptions, AppInfiniteQueryOptions } from './lib/react-query.types';
+export { OpenApiRouter } from './lib/config/router.context';
+export { OpenApiQueryConfig } from './lib/config/queryConfig.context';
+export type { InvalidationMap } from './lib/config/queryConfig.context';
+export { ns, resources } from './lib/config/i18n';
+export { AuthContext } from './lib/auth/auth.context';
+export { AuthGuard } from './lib/auth/AuthGuard';
+export type { AuthGuardProps } from './lib/auth/AuthGuard';

package/dist/index.mjs

@@ -1,253 +1,23 @@
-import { a as ns, i as RestUtils, n as ErrorHandler, o as resources, r as SharedErrorHandler, t as ApplicationException } from "./error-handling-DkPY7Asf.mjs";
-import { n as OpenApiRouter, t as AuthContext } from "./auth.context-Bu5KW2sI.mjs";
-import axios from "axios";
-import { z } from "zod";
-import { createContext, use, useCallback, useEffect, useMemo, useState } from "react";
-import { useQueryClient } from "@tanstack/react-query";
-import { jsx } from "react/jsx-runtime";
-
-//#region src/lib/rest/rest-client.ts
-var RestClient = class {
-	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 = (/* @__PURE__ */ 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");
-			}
-			(requestInfo.errorHandler ?? this.errorHandler).rethrowError(error);
-			throw error;
-		}
-	}
+import { RestClient } from "./lib/rest/rest-client.mjs";
+import { RestInterceptor } from "./lib/rest/rest-interceptor.mjs";
+import { RestUtils } from "./lib/rest/rest.utils.mjs";
+import { ApplicationException, ErrorHandler, SharedErrorHandler } from "./lib/rest/error-handling.mjs";
+import { OpenApiRouter } from "./lib/config/router.context.mjs";
+import { OpenApiQueryConfig } from "./lib/config/queryConfig.context.mjs";
+import { ns, resources } from "./lib/config/i18n.mjs";
+import { AuthContext } from "./lib/auth/auth.context.mjs";
+import { AuthGuard } from "./lib/auth/AuthGuard.mjs";
+export {
+  ApplicationException,
+  AuthContext,
+  AuthGuard,
+  ErrorHandler,
+  OpenApiQueryConfig,
+  OpenApiRouter,
+  RestClient,
+  RestInterceptor,
+  RestUtils,
+  SharedErrorHandler,
+  ns,
+  resources
 };
-
-//#endregion
-//#region src/lib/rest/rest-interceptor.ts
-var RestInterceptor = class {
-	interceptorIdMap = [];
-	constructor(applyInterceptor) {
-		this.applyInterceptor = applyInterceptor;
-	}
-	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);
-		}
-	}
-};
-
-//#endregion
-//#region src/lib/config/queryConfig.context.tsx
-let OpenApiQueryConfig;
-(function(_OpenApiQueryConfig) {
-	const Context = createContext({});
-	function Provider({ preferUpdate, invalidateCurrentModule, invalidationMap, crossTabInvalidation, onError, children }) {
-		const value = useMemo(() => ({
-			preferUpdate,
-			invalidateCurrentModule,
-			invalidationMap,
-			crossTabInvalidation,
-			onError
-		}), [
-			preferUpdate,
-			invalidateCurrentModule,
-			invalidationMap,
-			crossTabInvalidation,
-			onError
-		]);
-		return /* @__PURE__ */ jsx(Context.Provider, {
-			value,
-			children
-		});
-	}
-	_OpenApiQueryConfig.Provider = Provider;
-	_OpenApiQueryConfig.useConfig = () => {
-		return use(Context) ?? {};
-	};
-})(OpenApiQueryConfig || (OpenApiQueryConfig = {}));
-
-//#endregion
-//#region src/lib/react-query/cross-tab-invalidation.ts
-const CROSS_TAB_INVALIDATE_KEY = "__rq_invalidate__";
-const broadcastQueryInvalidation = (queryKeys) => {
-	localStorage.setItem(CROSS_TAB_INVALIDATE_KEY, JSON.stringify({
-		keys: queryKeys,
-		timestamp: Date.now()
-	}));
-};
-let isListenerSetUp = false;
-const setupCrossTabListener = (queryClient) => {
-	if (isListenerSetUp) return;
-	isListenerSetUp = true;
-	window.addEventListener("storage", (e) => {
-		if (e.key !== CROSS_TAB_INVALIDATE_KEY || !e.newValue) return;
-		try {
-			const { keys } = JSON.parse(e.newValue);
-			for (const queryKey of keys) queryClient.invalidateQueries({ queryKey });
-		} catch {}
-	});
-};
-
-//#endregion
-//#region src/lib/react-query/useMutationEffects.ts
-function useMutationEffects({ currentModule }) {
-	const queryClient = useQueryClient();
-	const config = OpenApiQueryConfig.useConfig();
-	useEffect(() => {
-		if (!config.crossTabInvalidation) return;
-		setupCrossTabListener(queryClient);
-	}, [queryClient, config.crossTabInvalidation]);
-	return { runMutationEffects: useCallback(async (data, variables, options = {}, updateKeys) => {
-		const { invalidateCurrentModule, invalidationMap, invalidateModules, invalidateKeys, preferUpdate } = options;
-		const shouldUpdate = preferUpdate ?? config.preferUpdate ?? false;
-		const shouldInvalidateCurrentModule = invalidateCurrentModule ?? config.invalidateCurrentModule ?? true;
-		const isQueryKeyEqual = (keyA, keyB) => keyA.length === keyB.length && keyA.every((item, index) => item === keyB[index]);
-		const isQueryKeyPrefix = (queryKey, prefixKey) => prefixKey.length <= queryKey.length && prefixKey.every((item, index) => item === queryKey[index]);
-		const mappedInvalidationKeys = invalidationMap?.[currentModule]?.(data, variables) ?? config.invalidationMap?.[currentModule]?.(data, variables);
-		const shouldInvalidateQuery = (queryKey) => {
-			const isUpdateKey = updateKeys?.some((key) => isQueryKeyEqual(queryKey, key));
-			if (shouldUpdate && isUpdateKey) return false;
-			const isCurrentModule = shouldInvalidateCurrentModule && queryKey[0] === currentModule;
-			const isInvalidateModule = !!invalidateModules && invalidateModules.some((module) => queryKey[0] === module);
-			const isInvalidateKey = !!invalidateKeys && invalidateKeys.some((key) => isQueryKeyPrefix(queryKey, key));
-			const isMappedKey = !!mappedInvalidationKeys && mappedInvalidationKeys.some((key) => isQueryKeyPrefix(queryKey, key));
-			return isCurrentModule || isInvalidateModule || isInvalidateKey || isMappedKey;
-		};
-		const invalidatedQueryKeys = [];
-		const shouldBroadcast = options.crossTabInvalidation ?? config.crossTabInvalidation;
-		queryClient.invalidateQueries({ predicate: ({ queryKey }) => {
-			const shouldInvalidate = shouldInvalidateQuery(queryKey);
-			if (shouldInvalidate && shouldBroadcast) invalidatedQueryKeys.push([...queryKey]);
-			return shouldInvalidate;
-		} });
-		if (shouldBroadcast && invalidatedQueryKeys.length > 0) broadcastQueryInvalidation(invalidatedQueryKeys);
-		if (shouldUpdate && updateKeys) updateKeys.map((queryKey) => queryClient.setQueryData(queryKey, data));
-	}, [
-		queryClient,
-		currentModule,
-		config.preferUpdate,
-		config.invalidateCurrentModule,
-		config.invalidationMap,
-		config.crossTabInvalidation
-	]) };
-}
-
-//#endregion
-//#region src/lib/config/workspace.context.tsx
-let OpenApiWorkspaceContext;
-(function(_OpenApiWorkspaceContext) {
-	const Context = createContext({});
-	_OpenApiWorkspaceContext.Provider = ({ values, children }) => {
-		const contextValues = useMemo(() => values ?? {}, [values]);
-		return /* @__PURE__ */ jsx(Context.Provider, {
-			value: contextValues,
-			children
-		});
-	};
-	_OpenApiWorkspaceContext.useContext = () => {
-		return use(Context);
-	};
-	_OpenApiWorkspaceContext.resolveParam = (context, name, value) => {
-		if (value != null) return value;
-		const workspaceValue = context[name];
-		if (workspaceValue == null) throw new Error(`Missing workspace context param "${name}"`);
-		return workspaceValue;
-	};
-})(OpenApiWorkspaceContext || (OpenApiWorkspaceContext = {}));
-const useWorkspaceContext = () => OpenApiWorkspaceContext.useContext();
-
-//#endregion
-//#region src/lib/auth/AuthGuard.tsx
-const AuthGuard = ({ type, redirectTo, children }) => {
-	const { isAuthenticated, routes, loadingState } = AuthContext.useAuth();
-	const { replace } = OpenApiRouter.useRouter();
-	const [hasMounted, setHasMounted] = useState(false);
-	useEffect(() => {
-		setHasMounted(true);
-	}, []);
-	if (!hasMounted) return loadingState;
-	if (type === "private" && !isAuthenticated) {
-		replace(redirectTo || routes?.unauthenticated || "/");
-		return null;
-	}
-	if (type === "public-only" && isAuthenticated) {
-		replace(redirectTo || routes?.authenticated || "/");
-		return null;
-	}
-	return children;
-};
-
-//#endregion
-export { ApplicationException, AuthContext, AuthGuard, ErrorHandler, OpenApiQueryConfig, OpenApiRouter, OpenApiWorkspaceContext, RestClient, RestInterceptor, RestUtils, SharedErrorHandler, ns, resources, useMutationEffects, useWorkspaceContext };

package/dist/lib/acl/AclGuard.d.ts

@@ -0,0 +1,8 @@
+import { PropsWithChildren } from 'react';
+import { AppAbilities } from './appAbility.types';
+interface AclGuardProps<TAppAbilities extends AppAbilities = AppAbilities> {
+    canUse: TAppAbilities;
+    redirectTo?: string;
+}
+export declare const createAclGuard: <TAppAbilities extends AppAbilities = AppAbilities>() => ({ canUse, redirectTo, children }: PropsWithChildren<AclGuardProps<TAppAbilities>>) => import('react').ReactNode;
+export {};

package/dist/lib/acl/AclGuard.mjs

@@ -0,0 +1,14 @@
+import { OpenApiRouter } from "../config/router.context.mjs";
+import { AbilityContext } from "./ability.context.mjs";
+const createAclGuard = () => ({ canUse, redirectTo = "/", children }) => {
+  const ability = AbilityContext.useAbility();
+  const { replace } = OpenApiRouter.useRouter();
+  if (!ability.can(canUse[0], canUse[1])) {
+    replace(redirectTo);
+    return null;
+  }
+  return children;
+};
+export {
+  createAclGuard
+};

package/dist/lib/acl/Can.d.ts

@@ -0,0 +1,9 @@
+import { AbilityTuple, PureAbility } from '@casl/ability';
+import { BoundCanProps } from '@casl/react';
+import { AppAbilities } from './appAbility.types';
+type CanAbility = PureAbility<AbilityTuple<AppAbilities[0], AppAbilities[1]>>;
+type CanProps<TAppAbilities extends AppAbilities = AppAbilities> = {
+    use: TAppAbilities;
+} & Omit<BoundCanProps<CanAbility>, "do" | "I" | "on" | "a" | "an" | "this">;
+export declare const Can: <TAppAbilities extends AppAbilities = AppAbilities>({ use, ...props }: CanProps<TAppAbilities>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/lib/acl/Can.mjs

@@ -0,0 +1,11 @@
+import { jsx } from "react/jsx-runtime";
+import { createContextualCan } from "@casl/react";
+import { AbilityContext } from "./ability.context.mjs";
+const ContextualCan = createContextualCan(AbilityContext.Consumer);
+const Can = ({ use, ...props }) => {
+  const [action, subject] = use;
+  return /* @__PURE__ */ jsx(ContextualCan, { ...props, do: action, on: subject });
+};
+export {
+  Can
+};

package/dist/lib/acl/ability.context.d.ts

@@ -0,0 +1,15 @@
+import { PropsWithChildren } from 'react';
+import { PureAbility, RawRuleOf } from '@casl/ability';
+import { PackRule } from '@casl/ability/extra';
+import { AppAbilities, AppAbility } from './appAbility.types';
+export declare namespace AbilityContext {
+    export const Consumer: import("react").Consumer<AppAbility>;
+    interface ProviderProps {
+        user?: {
+            aclRules?: PackRule<RawRuleOf<AppAbility>>[];
+        } | null;
+    }
+    export const Provider: ({ children }: PropsWithChildren<ProviderProps>) => import("react/jsx-runtime").JSX.Element;
+    export const useAbility: <TAppAbilities extends AppAbilities = AppAbilities>() => PureAbility<TAppAbilities>;
+    export {};
+}

package/dist/lib/acl/ability.context.mjs

@@ -0,0 +1,37 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, useState, useEffect } from "react";
+import { AbilityBuilder, createMongoAbility } from "@casl/ability";
+import { unpackRules } from "@casl/ability/extra";
+import { useAbility } from "@casl/react";
+import { AuthContext } from "../auth/auth.context.mjs";
+var AbilityContext;
+((AbilityContext2) => {
+  const createAppAbilityBuilder = () => new AbilityBuilder(createMongoAbility);
+  const initialAppAbility = createAppAbilityBuilder().build();
+  const Context = createContext({});
+  ({ Consumer: AbilityContext2.Consumer } = Context);
+  AbilityContext2.Provider = ({ children }) => {
+    const [ability, setAbility] = useState(initialAppAbility);
+    const { user } = AuthContext.useAuth();
+    useEffect(() => {
+      if (!user || !("aclRules" in user)) {
+        return;
+      }
+      const { can, build } = createAppAbilityBuilder();
+      const packedRules = user.aclRules;
+      const rules = unpackRules(packedRules);
+      rules.forEach(({ action, subject, conditions }) => {
+        can(action, subject, conditions);
+      });
+      setAbility(build());
+    }, [user]);
+    return /* @__PURE__ */ jsx(Context.Provider, { value: ability, children });
+  };
+  AbilityContext2.useAbility = () => {
+    const ability = useAbility(Context);
+    return ability;
+  };
+})(AbilityContext || (AbilityContext = {}));
+export {
+  AbilityContext
+};

package/dist/lib/acl/appAbility.types.d.ts

@@ -0,0 +1,3 @@
+import { AbilityTuple, PureAbility, Subject } from '@casl/ability';
+export type AppAbilities = AbilityTuple<string, Subject>;
+export type AppAbility = PureAbility<AppAbilities>;

package/dist/lib/assets/locales/en/translation.json.mjs

@@ -0,0 +1,8 @@
+const openapi = { "sharedErrors": { "dataValidation": "An error occurred while validating the data", "internalError": "An internal error occurred. This is most likely a bug on our end. Please try again later.", "networkError": "A network error occurred. Are you connected to the internet?", "canceledError": "The request was canceled.", "unknownError": "An unknown error occurred. Please try again later.", "unknownErrorWithCode": 'An unknown error occurred. Error code: "{{code}}"' } };
+const translationEN = {
+  openapi
+};
+export {
+  translationEN as default,
+  openapi
+};

package/dist/lib/assets/locales/sl/translation.json.mjs

@@ -0,0 +1,8 @@
+const openapi = { "sharedErrors": { "dataValidation": "Pri preverjanju podatkov je prišlo do napake", "internalError": "Prišlo je do notranje napake.", "networkError": "Prišlo je do napake v omrežju.", "canceledError": "Zahteva je bila preklicana.", "unknownError": "Prišlo je do neznane napake.", "unknownErrorWithCode": 'Prišlo je do neznane napake. Koda napake: "{{code}}"' } };
+const translationSL = {
+  openapi
+};
+export {
+  translationSL as default,
+  openapi
+};

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

@@ -0,0 +1,6 @@
+import { PropsWithChildren } from 'react';
+export interface AuthGuardProps {
+    type: "public-only" | "private";
+    redirectTo?: string;
+}
+export declare const AuthGuard: ({ type, redirectTo, children }: PropsWithChildren<AuthGuardProps>) => import('react').ReactNode;

package/dist/lib/auth/AuthGuard.mjs

@@ -0,0 +1,26 @@
+import { useState, useEffect } from "react";
+import { OpenApiRouter } from "../config/router.context.mjs";
+import { AuthContext } from "./auth.context.mjs";
+const AuthGuard = ({ type, redirectTo, children }) => {
+  const { isAuthenticated, routes, loadingState } = AuthContext.useAuth();
+  const { replace } = OpenApiRouter.useRouter();
+  const [hasMounted, setHasMounted] = useState(false);
+  useEffect(() => {
+    setHasMounted(true);
+  }, []);
+  if (!hasMounted) {
+    return loadingState;
+  }
+  if (type === "private" && !isAuthenticated) {
+    replace(redirectTo || routes?.unauthenticated || "/");
+    return null;
+  }
+  if (type === "public-only" && isAuthenticated) {
+    replace(redirectTo || routes?.authenticated || "/");
+    return null;
+  }
+  return children;
+};
+export {
+  AuthGuard
+};

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>;