@povio/openapi-codegen-cli 1.2.11 → 2.0.0-rc.0

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

@@ -0,0 +1,8 @@
+import type { PropsWithChildren } from "react";
+import type { 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/Can.d.ts

@@ -0,0 +1,9 @@
+import type { AbilityTuple, PureAbility } from "@casl/ability";
+import { type BoundCanProps } from "@casl/react";
+import type { 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/ability.context.d.ts

@@ -0,0 +1,15 @@
+import { type PureAbility, type RawRuleOf } from "@casl/ability";
+import { type PackRule } from "@casl/ability/extra";
+import { type PropsWithChildren } from "react";
+import type { 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, unknown>;
+    export {};
+}

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

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

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

@@ -0,0 +1,6 @@
+import { type 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/auth.context.d.ts

@@ -0,0 +1,22 @@
+import { type PropsWithChildren, type 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/config/queryConfig.context.d.ts

@@ -0,0 +1,9 @@
+export declare namespace OpenApiQueryConfig {
+    interface Type {
+        preferUpdate?: boolean;
+    }
+    type ProviderProps = Type;
+    export const Provider: ({ preferUpdate, children }: React.PropsWithChildren<ProviderProps>) => import("react/jsx-runtime").JSX.Element;
+    export const useConfig: () => Type;
+    export {};
+}

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

@@ -0,0 +1,9 @@
+import { type 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/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,20 @@
+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: (error: unknown) => string;
+}
+export declare class ErrorHandler<CodeT extends string> {
+    entries: ErrorEntry<CodeT | GeneralErrorCodes>[];
+    constructor(entries: ErrorEntry<CodeT>[]);
+    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/rest-client.d.ts

@@ -0,0 +1,20 @@
+import { AxiosRequestConfig, CreateAxiosDefaults } from "axios";
+import { GeneralErrorCodes } from "./error-handling";
+import { RestInterceptor } from "./rest-interceptor";
+import { RestClient as IRestClient, RequestConfig, RequestInfo, Response } from "./rest-client.types";
+export declare class RestClient implements IRestClient {
+    private readonly client;
+    constructor({ config, interceptors, }?: {
+        config?: CreateAxiosDefaults;
+        interceptors?: RestInterceptor<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.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.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;
+}