import * as z from "zod/v3";
import { ClosedEnum } from "../../types/enums.js";
import { Result as SafeParseResult } from "../../types/fp.js";
import { SDKValidationError } from "../errors/sdkvalidationerror.js";
/**
 * Type of operation: 'and' or 'or'.
 */
export declare const Filter2Type: {
    readonly And: "and";
    readonly Or: "or";
};
/**
 * Type of operation: 'and' or 'or'.
 */
export type Filter2Type = ClosedEnum<typeof Filter2Type>;
/**
 * Type of operation: 'and' or 'or'.
 */
export declare const FilterFilters2Type: {
    readonly And: "and";
    readonly Or: "or";
};
/**
 * Type of operation: 'and' or 'or'.
 */
export type FilterFilters2Type = ClosedEnum<typeof FilterFilters2Type>;
/**
 * Comparison operator: eq (equals), ne (not equal), gt (greater than), gte (greater than or equal), lt (less than), lte (less than or equal), in (in), nin (not in).
 */
export declare const FilterFilters2FiltersType: {
    readonly Eq: "eq";
    readonly Ne: "ne";
    readonly Gt: "gt";
    readonly Gte: "gte";
    readonly Lt: "lt";
    readonly Lte: "lte";
    readonly In: "in";
    readonly Nin: "nin";
};
/**
 * Comparison operator: eq (equals), ne (not equal), gt (greater than), gte (greater than or equal), lt (less than), lte (less than or equal), in (in), nin (not in).
 */
export type FilterFilters2FiltersType = ClosedEnum<typeof FilterFilters2FiltersType>;
export type FilterValue24 = string | number | boolean;
/**
 * The value to compare against the attribute key; supports string, number, boolean, or array types.
 */
export type FilterFiltersValue = string | number | boolean | Array<string | number | boolean>;
/**
 * A filter used to compare a specified attribute key to a given value using a defined comparison operation.
 */
export type FilterFilters1 = {
    /**
     * Comparison operator: eq (equals), ne (not equal), gt (greater than), gte (greater than or equal), lt (less than), lte (less than or equal), in (in), nin (not in).
     */
    type: FilterFilters2FiltersType;
    /**
     * The key to compare against the value.
     */
    key: string;
    /**
     * The value to compare against the attribute key; supports string, number, boolean, or array types.
     */
    value: string | number | boolean | Array<string | number | boolean>;
};
export type FilterFiltersFilters = FilterFilters1 | any;
/**
 * Combine multiple filters using 'and' or 'or'.
 */
export type FilterFilters2 = {
    /**
     * Type of operation: 'and' or 'or'.
     */
    type: FilterFilters2Type;
    /**
     * Array of filters to combine. Items can be ComparisonFilter or CompoundFilter.
     */
    filters: Array<FilterFilters1 | any>;
};
/**
 * Comparison operator: eq (equals), ne (not equal), gt (greater than), gte (greater than or equal), lt (less than), lte (less than or equal), in (in), nin (not in).
 */
export declare const FilterFiltersType: {
    readonly Eq: "eq";
    readonly Ne: "ne";
    readonly Gt: "gt";
    readonly Gte: "gte";
    readonly Lt: "lt";
    readonly Lte: "lte";
    readonly In: "in";
    readonly Nin: "nin";
};
/**
 * Comparison operator: eq (equals), ne (not equal), gt (greater than), gte (greater than or equal), lt (less than), lte (less than or equal), in (in), nin (not in).
 */
export type FilterFiltersType = ClosedEnum<typeof FilterFiltersType>;
export type FilterValue4 = string | number | boolean;
/**
 * The value to compare against the attribute key; supports string, number, boolean, or array types.
 */
export type FiltersValue = string | number | boolean | Array<string | number | boolean>;
/**
 * A filter used to compare a specified attribute key to a given value using a defined comparison operation.
 */
export type Filters1 = {
    /**
     * Comparison operator: eq (equals), ne (not equal), gt (greater than), gte (greater than or equal), lt (less than), lte (less than or equal), in (in), nin (not in).
     */
    type: FilterFiltersType;
    /**
     * The key to compare against the value.
     */
    key: string;
    /**
     * The value to compare against the attribute key; supports string, number, boolean, or array types.
     */
    value: string | number | boolean | Array<string | number | boolean>;
};
export type FilterFilters = (Filters1 & {
    type: "eq";
}) | (Filters1 & {
    type: "ne";
}) | (Filters1 & {
    type: "gt";
}) | (Filters1 & {
    type: "gte";
}) | (Filters1 & {
    type: "lt";
}) | (Filters1 & {
    type: "lte";
}) | (Filters1 & {
    type: "in";
}) | (Filters1 & {
    type: "nin";
}) | (FilterFilters2 & {
    type: "and";
}) | (FilterFilters2 & {
    type: "or";
});
/**
 * Combine multiple filters using 'and' or 'or'.
 */
export type Filter2 = {
    /**
     * Type of operation: 'and' or 'or'.
     */
    type: Filter2Type;
    /**
     * Array of filters to combine. Items can be ComparisonFilter or CompoundFilter.
     */
    filters: Array<(Filters1 & {
        type: "eq";
    }) | (Filters1 & {
        type: "ne";
    }) | (Filters1 & {
        type: "gt";
    }) | (Filters1 & {
        type: "gte";
    }) | (Filters1 & {
        type: "lt";
    }) | (Filters1 & {
        type: "lte";
    }) | (Filters1 & {
        type: "in";
    }) | (Filters1 & {
        type: "nin";
    }) | (FilterFilters2 & {
        type: "and";
    }) | (FilterFilters2 & {
        type: "or";
    })>;
};
/**
 * Comparison operator: eq (equals), ne (not equal), gt (greater than), gte (greater than or equal), lt (less than), lte (less than or equal), in (in), nin (not in).
 */
export declare const FilterType: {
    readonly Eq: "eq";
    readonly Ne: "ne";
    readonly Gt: "gt";
    readonly Gte: "gte";
    readonly Lt: "lt";
    readonly Lte: "lte";
    readonly In: "in";
    readonly Nin: "nin";
};
/**
 * Comparison operator: eq (equals), ne (not equal), gt (greater than), gte (greater than or equal), lt (less than), lte (less than or equal), in (in), nin (not in).
 */
export type FilterType = ClosedEnum<typeof FilterType>;
export type Value4 = string | number | boolean;
/**
 * The value to compare against the attribute key; supports string, number, boolean, or array types.
 */
export type FilterValue = string | number | boolean | Array<string | number | boolean>;
/**
 * A filter used to compare a specified attribute key to a given value using a defined comparison operation.
 */
export type Filter1 = {
    /**
     * Comparison operator: eq (equals), ne (not equal), gt (greater than), gte (greater than or equal), lt (less than), lte (less than or equal), in (in), nin (not in).
     */
    type: FilterType;
    /**
     * The key to compare against the value.
     */
    key: string;
    /**
     * The value to compare against the attribute key; supports string, number, boolean, or array types.
     */
    value: string | number | boolean | Array<string | number | boolean>;
};
export type Filter = (Filter1 & {
    type: "eq";
}) | (Filter1 & {
    type: "ne";
}) | (Filter1 & {
    type: "gt";
}) | (Filter1 & {
    type: "gte";
}) | (Filter1 & {
    type: "lt";
}) | (Filter1 & {
    type: "lte";
}) | (Filter1 & {
    type: "in";
}) | (Filter1 & {
    type: "nin";
}) | (Filter2 & {
    type: "and";
}) | (Filter2 & {
    type: "or";
});
/** @internal */
export declare const Filter2Type$inboundSchema: z.ZodNativeEnum<typeof Filter2Type>;
/** @internal */
export declare const Filter2Type$outboundSchema: z.ZodNativeEnum<typeof Filter2Type>;
/** @internal */
export declare const FilterFilters2Type$inboundSchema: z.ZodNativeEnum<typeof FilterFilters2Type>;
/** @internal */
export declare const FilterFilters2Type$outboundSchema: z.ZodNativeEnum<typeof FilterFilters2Type>;
/** @internal */
export declare const FilterFilters2FiltersType$inboundSchema: z.ZodNativeEnum<typeof FilterFilters2FiltersType>;
/** @internal */
export declare const FilterFilters2FiltersType$outboundSchema: z.ZodNativeEnum<typeof FilterFilters2FiltersType>;
/** @internal */
export declare const FilterValue24$inboundSchema: z.ZodType<FilterValue24, z.ZodTypeDef, unknown>;
/** @internal */
export type FilterValue24$Outbound = string | number | boolean;
/** @internal */
export declare const FilterValue24$outboundSchema: z.ZodType<FilterValue24$Outbound, z.ZodTypeDef, FilterValue24>;
export declare function filterValue24ToJSON(filterValue24: FilterValue24): string;
export declare function filterValue24FromJSON(jsonString: string): SafeParseResult<FilterValue24, SDKValidationError>;
/** @internal */
export declare const FilterFiltersValue$inboundSchema: z.ZodType<FilterFiltersValue, z.ZodTypeDef, unknown>;
/** @internal */
export type FilterFiltersValue$Outbound = string | number | boolean | Array<string | number | boolean>;
/** @internal */
export declare const FilterFiltersValue$outboundSchema: z.ZodType<FilterFiltersValue$Outbound, z.ZodTypeDef, FilterFiltersValue>;
export declare function filterFiltersValueToJSON(filterFiltersValue: FilterFiltersValue): string;
export declare function filterFiltersValueFromJSON(jsonString: string): SafeParseResult<FilterFiltersValue, SDKValidationError>;
/** @internal */
export declare const FilterFilters1$inboundSchema: z.ZodType<FilterFilters1, z.ZodTypeDef, unknown>;
/** @internal */
export type FilterFilters1$Outbound = {
    type: string;
    key: string;
    value: string | number | boolean | Array<string | number | boolean>;
};
/** @internal */
export declare const FilterFilters1$outboundSchema: z.ZodType<FilterFilters1$Outbound, z.ZodTypeDef, FilterFilters1>;
export declare function filterFilters1ToJSON(filterFilters1: FilterFilters1): string;
export declare function filterFilters1FromJSON(jsonString: string): SafeParseResult<FilterFilters1, SDKValidationError>;
/** @internal */
export declare const FilterFiltersFilters$inboundSchema: z.ZodType<FilterFiltersFilters, z.ZodTypeDef, unknown>;
/** @internal */
export type FilterFiltersFilters$Outbound = FilterFilters1$Outbound | any;
/** @internal */
export declare const FilterFiltersFilters$outboundSchema: z.ZodType<FilterFiltersFilters$Outbound, z.ZodTypeDef, FilterFiltersFilters>;
export declare function filterFiltersFiltersToJSON(filterFiltersFilters: FilterFiltersFilters): string;
export declare function filterFiltersFiltersFromJSON(jsonString: string): SafeParseResult<FilterFiltersFilters, SDKValidationError>;
/** @internal */
export declare const FilterFilters2$inboundSchema: z.ZodType<FilterFilters2, z.ZodTypeDef, unknown>;
/** @internal */
export type FilterFilters2$Outbound = {
    type: string;
    filters: Array<FilterFilters1$Outbound | any>;
};
/** @internal */
export declare const FilterFilters2$outboundSchema: z.ZodType<FilterFilters2$Outbound, z.ZodTypeDef, FilterFilters2>;
export declare function filterFilters2ToJSON(filterFilters2: FilterFilters2): string;
export declare function filterFilters2FromJSON(jsonString: string): SafeParseResult<FilterFilters2, SDKValidationError>;
/** @internal */
export declare const FilterFiltersType$inboundSchema: z.ZodNativeEnum<typeof FilterFiltersType>;
/** @internal */
export declare const FilterFiltersType$outboundSchema: z.ZodNativeEnum<typeof FilterFiltersType>;
/** @internal */
export declare const FilterValue4$inboundSchema: z.ZodType<FilterValue4, z.ZodTypeDef, unknown>;
/** @internal */
export type FilterValue4$Outbound = string | number | boolean;
/** @internal */
export declare const FilterValue4$outboundSchema: z.ZodType<FilterValue4$Outbound, z.ZodTypeDef, FilterValue4>;
export declare function filterValue4ToJSON(filterValue4: FilterValue4): string;
export declare function filterValue4FromJSON(jsonString: string): SafeParseResult<FilterValue4, SDKValidationError>;
/** @internal */
export declare const FiltersValue$inboundSchema: z.ZodType<FiltersValue, z.ZodTypeDef, unknown>;
/** @internal */
export type FiltersValue$Outbound = string | number | boolean | Array<string | number | boolean>;
/** @internal */
export declare const FiltersValue$outboundSchema: z.ZodType<FiltersValue$Outbound, z.ZodTypeDef, FiltersValue>;
export declare function filtersValueToJSON(filtersValue: FiltersValue): string;
export declare function filtersValueFromJSON(jsonString: string): SafeParseResult<FiltersValue, SDKValidationError>;
/** @internal */
export declare const Filters1$inboundSchema: z.ZodType<Filters1, z.ZodTypeDef, unknown>;
/** @internal */
export type Filters1$Outbound = {
    type: string;
    key: string;
    value: string | number | boolean | Array<string | number | boolean>;
};
/** @internal */
export declare const Filters1$outboundSchema: z.ZodType<Filters1$Outbound, z.ZodTypeDef, Filters1>;
export declare function filters1ToJSON(filters1: Filters1): string;
export declare function filters1FromJSON(jsonString: string): SafeParseResult<Filters1, SDKValidationError>;
/** @internal */
export declare const FilterFilters$inboundSchema: z.ZodType<FilterFilters, z.ZodTypeDef, unknown>;
/** @internal */
export type FilterFilters$Outbound = (Filters1$Outbound & {
    type: "eq";
}) | (Filters1$Outbound & {
    type: "ne";
}) | (Filters1$Outbound & {
    type: "gt";
}) | (Filters1$Outbound & {
    type: "gte";
}) | (Filters1$Outbound & {
    type: "lt";
}) | (Filters1$Outbound & {
    type: "lte";
}) | (Filters1$Outbound & {
    type: "in";
}) | (Filters1$Outbound & {
    type: "nin";
}) | (FilterFilters2$Outbound & {
    type: "and";
}) | (FilterFilters2$Outbound & {
    type: "or";
});
/** @internal */
export declare const FilterFilters$outboundSchema: z.ZodType<FilterFilters$Outbound, z.ZodTypeDef, FilterFilters>;
export declare function filterFiltersToJSON(filterFilters: FilterFilters): string;
export declare function filterFiltersFromJSON(jsonString: string): SafeParseResult<FilterFilters, SDKValidationError>;
/** @internal */
export declare const Filter2$inboundSchema: z.ZodType<Filter2, z.ZodTypeDef, unknown>;
/** @internal */
export type Filter2$Outbound = {
    type: string;
    filters: Array<(Filters1$Outbound & {
        type: "eq";
    }) | (Filters1$Outbound & {
        type: "ne";
    }) | (Filters1$Outbound & {
        type: "gt";
    }) | (Filters1$Outbound & {
        type: "gte";
    }) | (Filters1$Outbound & {
        type: "lt";
    }) | (Filters1$Outbound & {
        type: "lte";
    }) | (Filters1$Outbound & {
        type: "in";
    }) | (Filters1$Outbound & {
        type: "nin";
    }) | (FilterFilters2$Outbound & {
        type: "and";
    }) | (FilterFilters2$Outbound & {
        type: "or";
    })>;
};
/** @internal */
export declare const Filter2$outboundSchema: z.ZodType<Filter2$Outbound, z.ZodTypeDef, Filter2>;
export declare function filter2ToJSON(filter2: Filter2): string;
export declare function filter2FromJSON(jsonString: string): SafeParseResult<Filter2, SDKValidationError>;
/** @internal */
export declare const FilterType$inboundSchema: z.ZodNativeEnum<typeof FilterType>;
/** @internal */
export declare const FilterType$outboundSchema: z.ZodNativeEnum<typeof FilterType>;
/** @internal */
export declare const Value4$inboundSchema: z.ZodType<Value4, z.ZodTypeDef, unknown>;
/** @internal */
export type Value4$Outbound = string | number | boolean;
/** @internal */
export declare const Value4$outboundSchema: z.ZodType<Value4$Outbound, z.ZodTypeDef, Value4>;
export declare function value4ToJSON(value4: Value4): string;
export declare function value4FromJSON(jsonString: string): SafeParseResult<Value4, SDKValidationError>;
/** @internal */
export declare const FilterValue$inboundSchema: z.ZodType<FilterValue, z.ZodTypeDef, unknown>;
/** @internal */
export type FilterValue$Outbound = string | number | boolean | Array<string | number | boolean>;
/** @internal */
export declare const FilterValue$outboundSchema: z.ZodType<FilterValue$Outbound, z.ZodTypeDef, FilterValue>;
export declare function filterValueToJSON(filterValue: FilterValue): string;
export declare function filterValueFromJSON(jsonString: string): SafeParseResult<FilterValue, SDKValidationError>;
/** @internal */
export declare const Filter1$inboundSchema: z.ZodType<Filter1, z.ZodTypeDef, unknown>;
/** @internal */
export type Filter1$Outbound = {
    type: string;
    key: string;
    value: string | number | boolean | Array<string | number | boolean>;
};
/** @internal */
export declare const Filter1$outboundSchema: z.ZodType<Filter1$Outbound, z.ZodTypeDef, Filter1>;
export declare function filter1ToJSON(filter1: Filter1): string;
export declare function filter1FromJSON(jsonString: string): SafeParseResult<Filter1, SDKValidationError>;
/** @internal */
export declare const Filter$inboundSchema: z.ZodType<Filter, z.ZodTypeDef, unknown>;
/** @internal */
export type Filter$Outbound = (Filter1$Outbound & {
    type: "eq";
}) | (Filter1$Outbound & {
    type: "ne";
}) | (Filter1$Outbound & {
    type: "gt";
}) | (Filter1$Outbound & {
    type: "gte";
}) | (Filter1$Outbound & {
    type: "lt";
}) | (Filter1$Outbound & {
    type: "lte";
}) | (Filter1$Outbound & {
    type: "in";
}) | (Filter1$Outbound & {
    type: "nin";
}) | (Filter2$Outbound & {
    type: "and";
}) | (Filter2$Outbound & {
    type: "or";
});
/** @internal */
export declare const Filter$outboundSchema: z.ZodType<Filter$Outbound, z.ZodTypeDef, Filter>;
export declare function filterToJSON(filter: Filter): string;
export declare function filterFromJSON(jsonString: string): SafeParseResult<Filter, SDKValidationError>;
//# sourceMappingURL=filter.d.ts.map