import { AttachType } from '@react-three/fiber/dist/declarations/src/core/renderer';
import { Material } from 'three';
import * as React_2 from 'react';
import * as THREE from 'three';

declare type CSMPatchMap = {
    [keyword: string]: {
        [toReplace: string]: string | {
            value: string;
            type: "fs" | "vs";
        };
    };
};

declare type CSMProxy<T extends MaterialConstructor> = InstanceType<T> & {
    vertexShader: string;
    fragmentShader: string;
    uniforms: Uniform;
    update: (opts: Omit<CustomShaderMaterialBaseParameters<T>, "baseMaterial">) => void;
    __csm: Omit<CustomShaderMaterialBaseParameters<T>, "baseMaterial"> & {
        prevOnBeforeCompile: THREE.Material["onBeforeCompile"];
        baseMaterial: THREE.Material;
    };
};

declare class CustomShaderMaterial<T extends TYPES.MaterialConstructor = typeof THREE.Material> extends THREE.Material {
    uniforms: TYPES.Uniform;
    vertexShader: string;
    fragmentShader: string;
    constructor({ baseMaterial, vertexShader, fragmentShader, uniforms, patchMap, cacheKey, ...opts }: TYPES.CustomShaderMaterialParameters<T>);
    update({ fragmentShader: _fs, vertexShader: _vs, uniforms, cacheKey, patchMap, }: Omit<TYPES.CustomShaderMaterialBaseParameters<T>, "baseMaterial">): void;
    clone(): any;
}

declare type CustomShaderMaterialBaseParameters<T extends MaterialConstructor> = {
    baseMaterial: T | InstanceType<T>;
    vertexShader?: string;
    fragmentShader?: string;
    uniforms?: Uniform;
    patchMap?: CSMPatchMap;
    cacheKey?: () => string;
};

declare type CustomShaderMaterialParameters<T extends MaterialConstructor> = CustomShaderMaterialBaseParameters<T> & (MaterialParams<T> extends undefined ? any : MaterialParams<T>);

export declare type CustomShaderMaterialProps<T extends MaterialConstructor> = CustomShaderMaterialParameters<T> & {};

declare const _default: <T extends MaterialConstructor = typeof Material>(props: CustomShaderMaterialProps<T> & {
    ref?: React_2.Ref<CustomShaderMaterial<T>>;
    attach?: AttachType;
}) => React_2.ReactElement;
export default _default;

declare interface IUniform<TValue = any> {
    value: TValue;
}

declare type MaterialConstructor = new (...opts: any[]) => THREE.Material;

declare type MaterialParams<T extends MaterialConstructor> = ConstructorParameters<T>[0];

declare namespace TYPES {
    export {
        IUniform,
        Uniform,
        MaterialConstructor,
        CSMPatchMap,
        CustomShaderMaterialBaseParameters,
        CustomShaderMaterialParameters,
        CSMProxy
    }
}

declare type Uniform = {
    [key: string]: IUniform;
};

export { }