import { ZodError, ZodTypeAny, z, ZodEffects, ZodObject, ZodType, ZodSchema } from 'zod';
import { Observable } from 'rxjs';
import * as _nestjs_swagger_dist_interfaces_open_api_spec_interface_js from '@nestjs/swagger/dist/interfaces/open-api-spec.interface.js';
import { PipeTransform, ArgumentMetadata, DynamicModule, INestApplication, ModuleMetadata } from '@nestjs/common';
import { OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
import { OpenAPIObject, SwaggerCustomOptions } from '@nestjs/swagger';

declare abstract class SmpAbstractZodDto {
    static smpMapError?: (error: ZodError) => unknown;
    static zodSchema: ZodTypeAny;
    static fromPlain<T extends typeof SmpAbstractZodDto, U extends Partial<z.input<T["zodSchema"]>>>(this: T, input: U): InstanceType<T>;
    static fromPlain$<T extends typeof SmpAbstractZodDto, U extends Partial<z.input<T["zodSchema"]>>>(this: T, input: U): Observable<InstanceType<T>>;
    static isSmpZodDto(): this is SmpAbstractZodDto;
    /**
     * A dynamic class generator. You can either use the returned value or extend if you want to override the dynamic name
     * @example
     *
     */
    static toGenericResponseDto<T extends typeof SmpAbstractZodDto>(this: T): {
        new (): {};
        smpMapError?: ((error: ZodError) => unknown) | undefined;
        fromPlain: typeof SmpAbstractZodDto.fromPlain;
        fromPlain$: typeof SmpAbstractZodDto.fromPlain$;
        isSmpZodDto: typeof SmpAbstractZodDto.isSmpZodDto;
        toGenericResponseDto: typeof SmpAbstractZodDto.toGenericResponseDto;
        zodSchema: z.ZodObject<{
            messages: z.ZodTypeAny;
        } & {
            data: T["zodSchema"];
        }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
            messages: z.ZodTypeAny;
        } & {
            data: T["zodSchema"];
        }>, any> extends infer T_1 ? { [k in keyof T_1]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
            messages: z.ZodTypeAny;
        } & {
            data: T["zodSchema"];
        }>, any>[k]; } : never, z.baseObjectInputType<{
            messages: z.ZodTypeAny;
        } & {
            data: T["zodSchema"];
        }> extends infer T_2 ? { [k_1 in keyof T_2]: z.baseObjectInputType<{
            messages: z.ZodTypeAny;
        } & {
            data: T["zodSchema"];
        }>[k_1]; } : never>;
    };
    toPlain(): any;
    toString(): string;
}

interface SmpZodValidationSchemas {
    body: typeof SmpAbstractZodDto | ZodTypeAny | Record<string, ZodTypeAny>;
    query: typeof SmpAbstractZodDto | ZodEffects<ZodObject<any>> | ZodObject<any> | Record<string, ZodTypeAny>;
    param: typeof SmpAbstractZodDto | ZodEffects<ZodObject<any>> | ZodObject<any> | Record<string, ZodTypeAny>;
}

/**
 * Use this if you want just to validate your request and get the parsed items in your standard NestJS entities: @Body, @Param, @Query
 * while ALSO managing @nestjs/swagger document creation.
 * If you just want the validation, just use @SmpUseZodValidationPipe
 * @example
 * @SmpZodApi({body: someZodSchema})
 */
declare const SmpZodApi: (schemas: Partial<SmpZodValidationSchemas>, opts?: {
    validate?: boolean;
}) => <TFunction extends Function, Y>(target: TFunction | object, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

/**
 * Attach a DTO-specific Zod error mapper.
 * Useful when a global SmpZodValidationPipe is active but one DTO needs a custom error shape.
 */
declare function SmpZodMapError(mapError: (error: ZodError) => unknown): <T extends typeof SmpAbstractZodDto>(target: T) => void;

type SmpGeneratedZodDto<T extends ZodTypeAny> = Omit<typeof SmpAbstractZodDto, "new" | "zodSchema"> & {
    zodSchema: T;
} & (new () => z.infer<T> & Omit<SmpAbstractZodDto, "toPlain"> & {
    toPlain: () => z.output<T>;
});
/**
 * A dynamic class generator.
 * Suggested usage: extend! Don't use the returned class as is for the best experience
 * @example
 * ```ts
 * const fooSchema = z.object({
 *     firstName: z.string(),
 *     lastName: z.string(),
 *     age: z.number().optional()
 * });
 *
 * class SmpFooDto extends smpGenerateSmpZodDto(fooSchema) {
 *     foo: string = "foo";
 * }
 *
 * class MyController {
 *     someMethod(body: SmpFooDto) {
 *         body.firstName // works
 *         body.foo // works
 *     }
 * }
 * ```
 * @param schema
 */
declare function smpGenerateSmpZodDto<T extends ZodTypeAny>(schema: T): SmpGeneratedZodDto<T>;

interface SmpZodValidationPipeOptions {
    mapError?: (error: ZodError) => any;
}

/**
 * Use this if you want just to validate your request and get the parsed items in your standard NestJS entities: @Body, @Param, @Query
 */
declare function SmpUseZodValidationPipe(schemas: Partial<SmpZodValidationSchemas>, options?: SmpZodValidationPipeOptions): <TFunction extends Function, Y>(target: TFunction | object, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

declare class SmpZodOpenApiUtils {
    static getDefaultSchemaName(schema: ZodTypeAny, fallback?: string): string;
    static getDescription(schema: ZodTypeAny): string | undefined;
    static getOpenApiRefId(schema: ZodTypeAny): string | undefined;
    static isZodEffects(input: ZodTypeAny): input is ZodEffects<any>;
    static toZodObject(input: SmpZodValidationSchemas["param"] | SmpZodValidationSchemas["body"] | SmpZodValidationSchemas["query"]): ZodType;
    static unwrap(schema: ZodType): ZodType;
    static unwrapEffects(schema: ZodType): ZodType;
    protected static _getOpenApiRefId(schema: ZodTypeAny): string | undefined;
    protected static _hash(input: string): string;
}

declare function smpZodToOpenApiRef(schema: ZodSchema, name?: string): {
    $ref: string;
};
declare function smpZodToOpenApi(schema: ZodSchema, name?: string): Record<string, _nestjs_swagger_dist_interfaces_open_api_spec_interface_js.SchemaObject | _nestjs_swagger_dist_interfaces_open_api_spec_interface_js.ReferenceObject>;

/**
 * Use this if you want just to validate your request and get the parsed items in your standard NestJS entities: @Body, @Param, @Query
 * You can use SmpUseZodValidationPipe, but you can also use this in combination of @UsePipe
 * @example
 * @UsePipe(new SmpZodValidationPipe({body: someZodSchema}))
 */
declare class SmpZodValidationPipe implements PipeTransform {
    protected readonly _schemas?: Partial<SmpZodValidationSchemas> | undefined;
    protected readonly _mapError?: (error: ZodError) => any;
    constructor(_schemas?: Partial<SmpZodValidationSchemas> | undefined, options?: SmpZodValidationPipeOptions);
    transform(value: any, metadata: ArgumentMetadata): Promise<any>;
    protected _getMapError(metadata: ArgumentMetadata): ((error: ZodError) => unknown) | undefined;
    protected _validate(value: any, metadata: ArgumentMetadata, selectedSchemas: Partial<SmpZodValidationSchemas>[keyof SmpZodValidationSchemas]): Promise<any>;
}

declare const smpZodOpenApiModuleFeatures: {
    SmpZodValidationPipe: {
        providers: {
            provide: string;
            useFactory: () => SmpZodValidationPipe;
        }[];
    };
};
interface SmpZodOpenApiModuleOpts {
    features?: (keyof typeof smpZodOpenApiModuleFeatures)[];
}
type SmpZodOpenApiSwaggerOptions = Pick<SwaggerCustomOptions, "patchDocumentOnRequest" | "useGlobalPrefix"> & {
    path?: string;
};
interface SmpGenerateOpenApiDocOptions {
    contact?: {
        name: string;
        url: string;
        email: string;
    };
    description?: string;
    externalDoc?: OpenAPIObject["externalDocs"];
    servers?: OpenAPIObject["servers"];
    title?: string;
    version?: string;
}
declare class SmpZodOpenApiModule {
    static get REGISTRY(): Readonly<OpenAPIRegistry>;
    private static _initialized;
    private static _registry;
    private static _zodPatched;
    constructor();
    static forRoot(config?: Partial<SmpZodOpenApiModuleOpts>): DynamicModule;
    static forRootAsync(factory: () => Promise<Partial<SmpZodOpenApiModuleOpts>>): Promise<DynamicModule>;
    static generateOpenApiDoc(app: INestApplication, opts?: SmpGenerateOpenApiDocOptions): OpenAPIObject;
    static patchZodWithOpenApi(): void;
    static setupSwaggerUi(app: INestApplication, openApiDoc: OpenAPIObject, opts?: SmpZodOpenApiSwaggerOptions): void;
    protected static _getDynamicConfig(features: (keyof typeof smpZodOpenApiModuleFeatures)[]): ModuleMetadata;
}

export { SmpAbstractZodDto, SmpUseZodValidationPipe, SmpZodApi, SmpZodMapError, SmpZodOpenApiModule, SmpZodOpenApiUtils, SmpZodValidationPipe, type SmpZodValidationPipeOptions, type SmpZodValidationSchemas, smpGenerateSmpZodDto, smpZodToOpenApi, smpZodToOpenApiRef };