import * as z from "zod";
import { Result as SafeParseResult } from "../../../types/fp.js";
import { SDKValidationError } from "../errors/sdkvalidationerror.js";
import { MaskingRule, MaskingRule$Outbound } from "./maskingrule.js";
/**
 * UCAST JSON object describing the conditions under which the query is true.
 */
export type CompileResultMultitargetQuery = {};
export type Ucast = {
    /**
     * UCAST JSON object describing the conditions under which the query is true.
     */
    query?: CompileResultMultitargetQuery | undefined;
    /**
     * Column masking rules, where the first two nested keys represent the entity name and the property name, and the value describes which masking function to use.
     */
    masks?: {
        [k: string]: {
            [k: string]: MaskingRule;
        };
    } | undefined;
};
export type Sqlserver = {
    /**
     * String representing the SQL equivalent of the conditions under which the query is true.
     */
    query?: string | undefined;
    /**
     * Column masking rules, where the first two nested keys represent the table name and the column name, and the value describes which masking function to use.
     */
    masks?: {
        [k: string]: {
            [k: string]: MaskingRule;
        };
    } | undefined;
};
export type Mysql = {
    /**
     * String representing the SQL equivalent of the conditions under which the query is true.
     */
    query?: string | undefined;
    /**
     * Column masking rules, where the first two nested keys represent the table name and the column name, and the value describes which masking function to use.
     */
    masks?: {
        [k: string]: {
            [k: string]: MaskingRule;
        };
    } | undefined;
};
export type Postgresql = {
    /**
     * String representing the SQL equivalent of the conditions under which the query is true
     */
    query?: string | undefined;
    /**
     * Column masking rules, where the first two nested keys represent the table name and the column name, and the value describes which masking function to use.
     */
    masks?: {
        [k: string]: {
            [k: string]: MaskingRule;
        };
    } | undefined;
};
export type Sqlite = {
    /**
     * String representing the SQL equivalent of the conditions under which the query is true
     */
    query?: string | undefined;
    /**
     * Column masking rules, where the first two nested keys represent the table name and the column name, and the value describes which masking function to use.
     */
    masks?: {
        [k: string]: {
            [k: string]: MaskingRule;
        };
    } | undefined;
};
export type Targets = {
    ucast?: Ucast | undefined;
    sqlserver?: Sqlserver | undefined;
    mysql?: Mysql | undefined;
    postgresql?: Postgresql | undefined;
    sqlite?: Sqlite | undefined;
};
/**
 * The partially evaluated result of the query in each target dialect.
 */
export type CompileResultMultitargetResult = {
    targets?: Targets | undefined;
    additionalProperties?: {
        [k: string]: any;
    };
};
/**
 * The partially evaluated result of the query, for each target dialect. Result will be empty if the query is never true.
 */
export type CompileResultMultitarget = {
    /**
     * The partially evaluated result of the query in each target dialect.
     */
    result?: CompileResultMultitargetResult | undefined;
};
/** @internal */
export declare const CompileResultMultitargetQuery$inboundSchema: z.ZodType<CompileResultMultitargetQuery, z.ZodTypeDef, unknown>;
/** @internal */
export type CompileResultMultitargetQuery$Outbound = {};
/** @internal */
export declare const CompileResultMultitargetQuery$outboundSchema: z.ZodType<CompileResultMultitargetQuery$Outbound, z.ZodTypeDef, CompileResultMultitargetQuery>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace CompileResultMultitargetQuery$ {
    /** @deprecated use `CompileResultMultitargetQuery$inboundSchema` instead. */
    const inboundSchema: z.ZodType<CompileResultMultitargetQuery, z.ZodTypeDef, unknown>;
    /** @deprecated use `CompileResultMultitargetQuery$outboundSchema` instead. */
    const outboundSchema: z.ZodType<CompileResultMultitargetQuery$Outbound, z.ZodTypeDef, CompileResultMultitargetQuery>;
    /** @deprecated use `CompileResultMultitargetQuery$Outbound` instead. */
    type Outbound = CompileResultMultitargetQuery$Outbound;
}
export declare function compileResultMultitargetQueryToJSON(compileResultMultitargetQuery: CompileResultMultitargetQuery): string;
export declare function compileResultMultitargetQueryFromJSON(jsonString: string): SafeParseResult<CompileResultMultitargetQuery, SDKValidationError>;
/** @internal */
export declare const Ucast$inboundSchema: z.ZodType<Ucast, z.ZodTypeDef, unknown>;
/** @internal */
export type Ucast$Outbound = {
    query?: CompileResultMultitargetQuery$Outbound | undefined;
    masks?: {
        [k: string]: {
            [k: string]: MaskingRule$Outbound;
        };
    } | undefined;
};
/** @internal */
export declare const Ucast$outboundSchema: z.ZodType<Ucast$Outbound, z.ZodTypeDef, Ucast>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace Ucast$ {
    /** @deprecated use `Ucast$inboundSchema` instead. */
    const inboundSchema: z.ZodType<Ucast, z.ZodTypeDef, unknown>;
    /** @deprecated use `Ucast$outboundSchema` instead. */
    const outboundSchema: z.ZodType<Ucast$Outbound, z.ZodTypeDef, Ucast>;
    /** @deprecated use `Ucast$Outbound` instead. */
    type Outbound = Ucast$Outbound;
}
export declare function ucastToJSON(ucast: Ucast): string;
export declare function ucastFromJSON(jsonString: string): SafeParseResult<Ucast, SDKValidationError>;
/** @internal */
export declare const Sqlserver$inboundSchema: z.ZodType<Sqlserver, z.ZodTypeDef, unknown>;
/** @internal */
export type Sqlserver$Outbound = {
    query?: string | undefined;
    masks?: {
        [k: string]: {
            [k: string]: MaskingRule$Outbound;
        };
    } | undefined;
};
/** @internal */
export declare const Sqlserver$outboundSchema: z.ZodType<Sqlserver$Outbound, z.ZodTypeDef, Sqlserver>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace Sqlserver$ {
    /** @deprecated use `Sqlserver$inboundSchema` instead. */
    const inboundSchema: z.ZodType<Sqlserver, z.ZodTypeDef, unknown>;
    /** @deprecated use `Sqlserver$outboundSchema` instead. */
    const outboundSchema: z.ZodType<Sqlserver$Outbound, z.ZodTypeDef, Sqlserver>;
    /** @deprecated use `Sqlserver$Outbound` instead. */
    type Outbound = Sqlserver$Outbound;
}
export declare function sqlserverToJSON(sqlserver: Sqlserver): string;
export declare function sqlserverFromJSON(jsonString: string): SafeParseResult<Sqlserver, SDKValidationError>;
/** @internal */
export declare const Mysql$inboundSchema: z.ZodType<Mysql, z.ZodTypeDef, unknown>;
/** @internal */
export type Mysql$Outbound = {
    query?: string | undefined;
    masks?: {
        [k: string]: {
            [k: string]: MaskingRule$Outbound;
        };
    } | undefined;
};
/** @internal */
export declare const Mysql$outboundSchema: z.ZodType<Mysql$Outbound, z.ZodTypeDef, Mysql>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace Mysql$ {
    /** @deprecated use `Mysql$inboundSchema` instead. */
    const inboundSchema: z.ZodType<Mysql, z.ZodTypeDef, unknown>;
    /** @deprecated use `Mysql$outboundSchema` instead. */
    const outboundSchema: z.ZodType<Mysql$Outbound, z.ZodTypeDef, Mysql>;
    /** @deprecated use `Mysql$Outbound` instead. */
    type Outbound = Mysql$Outbound;
}
export declare function mysqlToJSON(mysql: Mysql): string;
export declare function mysqlFromJSON(jsonString: string): SafeParseResult<Mysql, SDKValidationError>;
/** @internal */
export declare const Postgresql$inboundSchema: z.ZodType<Postgresql, z.ZodTypeDef, unknown>;
/** @internal */
export type Postgresql$Outbound = {
    query?: string | undefined;
    masks?: {
        [k: string]: {
            [k: string]: MaskingRule$Outbound;
        };
    } | undefined;
};
/** @internal */
export declare const Postgresql$outboundSchema: z.ZodType<Postgresql$Outbound, z.ZodTypeDef, Postgresql>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace Postgresql$ {
    /** @deprecated use `Postgresql$inboundSchema` instead. */
    const inboundSchema: z.ZodType<Postgresql, z.ZodTypeDef, unknown>;
    /** @deprecated use `Postgresql$outboundSchema` instead. */
    const outboundSchema: z.ZodType<Postgresql$Outbound, z.ZodTypeDef, Postgresql>;
    /** @deprecated use `Postgresql$Outbound` instead. */
    type Outbound = Postgresql$Outbound;
}
export declare function postgresqlToJSON(postgresql: Postgresql): string;
export declare function postgresqlFromJSON(jsonString: string): SafeParseResult<Postgresql, SDKValidationError>;
/** @internal */
export declare const Sqlite$inboundSchema: z.ZodType<Sqlite, z.ZodTypeDef, unknown>;
/** @internal */
export type Sqlite$Outbound = {
    query?: string | undefined;
    masks?: {
        [k: string]: {
            [k: string]: MaskingRule$Outbound;
        };
    } | undefined;
};
/** @internal */
export declare const Sqlite$outboundSchema: z.ZodType<Sqlite$Outbound, z.ZodTypeDef, Sqlite>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace Sqlite$ {
    /** @deprecated use `Sqlite$inboundSchema` instead. */
    const inboundSchema: z.ZodType<Sqlite, z.ZodTypeDef, unknown>;
    /** @deprecated use `Sqlite$outboundSchema` instead. */
    const outboundSchema: z.ZodType<Sqlite$Outbound, z.ZodTypeDef, Sqlite>;
    /** @deprecated use `Sqlite$Outbound` instead. */
    type Outbound = Sqlite$Outbound;
}
export declare function sqliteToJSON(sqlite: Sqlite): string;
export declare function sqliteFromJSON(jsonString: string): SafeParseResult<Sqlite, SDKValidationError>;
/** @internal */
export declare const Targets$inboundSchema: z.ZodType<Targets, z.ZodTypeDef, unknown>;
/** @internal */
export type Targets$Outbound = {
    ucast?: Ucast$Outbound | undefined;
    sqlserver?: Sqlserver$Outbound | undefined;
    mysql?: Mysql$Outbound | undefined;
    postgresql?: Postgresql$Outbound | undefined;
    sqlite?: Sqlite$Outbound | undefined;
};
/** @internal */
export declare const Targets$outboundSchema: z.ZodType<Targets$Outbound, z.ZodTypeDef, Targets>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace Targets$ {
    /** @deprecated use `Targets$inboundSchema` instead. */
    const inboundSchema: z.ZodType<Targets, z.ZodTypeDef, unknown>;
    /** @deprecated use `Targets$outboundSchema` instead. */
    const outboundSchema: z.ZodType<Targets$Outbound, z.ZodTypeDef, Targets>;
    /** @deprecated use `Targets$Outbound` instead. */
    type Outbound = Targets$Outbound;
}
export declare function targetsToJSON(targets: Targets): string;
export declare function targetsFromJSON(jsonString: string): SafeParseResult<Targets, SDKValidationError>;
/** @internal */
export declare const CompileResultMultitargetResult$inboundSchema: z.ZodType<CompileResultMultitargetResult, z.ZodTypeDef, unknown>;
/** @internal */
export type CompileResultMultitargetResult$Outbound = {
    targets?: Targets$Outbound | undefined;
    [additionalProperties: string]: unknown;
};
/** @internal */
export declare const CompileResultMultitargetResult$outboundSchema: z.ZodType<CompileResultMultitargetResult$Outbound, z.ZodTypeDef, CompileResultMultitargetResult>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace CompileResultMultitargetResult$ {
    /** @deprecated use `CompileResultMultitargetResult$inboundSchema` instead. */
    const inboundSchema: z.ZodType<CompileResultMultitargetResult, z.ZodTypeDef, unknown>;
    /** @deprecated use `CompileResultMultitargetResult$outboundSchema` instead. */
    const outboundSchema: z.ZodType<CompileResultMultitargetResult$Outbound, z.ZodTypeDef, CompileResultMultitargetResult>;
    /** @deprecated use `CompileResultMultitargetResult$Outbound` instead. */
    type Outbound = CompileResultMultitargetResult$Outbound;
}
export declare function compileResultMultitargetResultToJSON(compileResultMultitargetResult: CompileResultMultitargetResult): string;
export declare function compileResultMultitargetResultFromJSON(jsonString: string): SafeParseResult<CompileResultMultitargetResult, SDKValidationError>;
/** @internal */
export declare const CompileResultMultitarget$inboundSchema: z.ZodType<CompileResultMultitarget, z.ZodTypeDef, unknown>;
/** @internal */
export type CompileResultMultitarget$Outbound = {
    result?: CompileResultMultitargetResult$Outbound | undefined;
};
/** @internal */
export declare const CompileResultMultitarget$outboundSchema: z.ZodType<CompileResultMultitarget$Outbound, z.ZodTypeDef, CompileResultMultitarget>;
/**
 * @internal
 * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
 */
export declare namespace CompileResultMultitarget$ {
    /** @deprecated use `CompileResultMultitarget$inboundSchema` instead. */
    const inboundSchema: z.ZodType<CompileResultMultitarget, z.ZodTypeDef, unknown>;
    /** @deprecated use `CompileResultMultitarget$outboundSchema` instead. */
    const outboundSchema: z.ZodType<CompileResultMultitarget$Outbound, z.ZodTypeDef, CompileResultMultitarget>;
    /** @deprecated use `CompileResultMultitarget$Outbound` instead. */
    type Outbound = CompileResultMultitarget$Outbound;
}
export declare function compileResultMultitargetToJSON(compileResultMultitarget: CompileResultMultitarget): string;
export declare function compileResultMultitargetFromJSON(jsonString: string): SafeParseResult<CompileResultMultitarget, SDKValidationError>;
//# sourceMappingURL=compileresultmultitarget.d.ts.map