/*
 * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
 */

import * as z from "zod/v3";
import { safeParse } from "../../lib/schemas.js";
import { ClosedEnum } from "../../types/enums.js";
import { Result as SafeParseResult } from "../../types/fp.js";
import { SDKValidationError } from "../errors/sdkvalidationerror.js";
import {
  ComparisonFilter,
  ComparisonFilter$inboundSchema,
  ComparisonFilter$Outbound,
  ComparisonFilter$outboundSchema,
} from "./comparisonfilter.js";

export const CompoundFilterType = {
  And: "and",
  Or: "or",
} as const;
export type CompoundFilterType = ClosedEnum<typeof CompoundFilterType>;

export type CompoundFilter = {
  type: CompoundFilterType;
  filters: Array<
    | (ComparisonFilter & { type: "eq" })
    | (ComparisonFilter & { type: "ne" })
    | (ComparisonFilter & { type: "gt" })
    | (ComparisonFilter & { type: "gte" })
    | (ComparisonFilter & { type: "lt" })
    | (ComparisonFilter & { type: "lte" })
    | (CompoundFilter & { type: "and" })
    | (CompoundFilter & { type: "or" })
  >;
};

export type Filters =
  | (ComparisonFilter & { type: "eq" })
  | (ComparisonFilter & { type: "ne" })
  | (ComparisonFilter & { type: "gt" })
  | (ComparisonFilter & { type: "gte" })
  | (ComparisonFilter & { type: "lt" })
  | (ComparisonFilter & { type: "lte" })
  | (CompoundFilter & { type: "and" })
  | (CompoundFilter & { type: "or" });

/** @internal */
export const CompoundFilterType$inboundSchema: z.ZodNativeEnum<
  typeof CompoundFilterType
> = z.nativeEnum(CompoundFilterType);
/** @internal */
export const CompoundFilterType$outboundSchema: z.ZodNativeEnum<
  typeof CompoundFilterType
> = CompoundFilterType$inboundSchema;

/** @internal */
export const CompoundFilter$inboundSchema: z.ZodType<
  CompoundFilter,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: CompoundFilterType$inboundSchema,
  filters: z.array(
    z.union([
      ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("eq") })),
      ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("ne") })),
      ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("gt") })),
      ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("gte") })),
      ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("lt") })),
      ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("lte") })),
      z.lazy(() => CompoundFilter$inboundSchema).and(
        z.object({ type: z.literal("and") }),
      ),
      z.lazy(() => CompoundFilter$inboundSchema).and(
        z.object({ type: z.literal("or") }),
      ),
    ]),
  ),
});
/** @internal */
export type CompoundFilter$Outbound = {
  type: string;
  filters: Array<
    | (ComparisonFilter$Outbound & { type: "eq" })
    | (ComparisonFilter$Outbound & { type: "ne" })
    | (ComparisonFilter$Outbound & { type: "gt" })
    | (ComparisonFilter$Outbound & { type: "gte" })
    | (ComparisonFilter$Outbound & { type: "lt" })
    | (ComparisonFilter$Outbound & { type: "lte" })
    | (CompoundFilter$Outbound & { type: "and" })
    | (CompoundFilter$Outbound & { type: "or" })
  >;
};

/** @internal */
export const CompoundFilter$outboundSchema: z.ZodType<
  CompoundFilter$Outbound,
  z.ZodTypeDef,
  CompoundFilter
> = z.object({
  type: CompoundFilterType$outboundSchema,
  filters: z.array(
    z.union([
      ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("eq") })),
      ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("ne") })),
      ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("gt") })),
      ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("gte") })),
      ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("lt") })),
      ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("lte") })),
      z.lazy(() => CompoundFilter$outboundSchema).and(
        z.object({ type: z.literal("and") }),
      ),
      z.lazy(() => CompoundFilter$outboundSchema).and(
        z.object({ type: z.literal("or") }),
      ),
    ]),
  ),
});

export function compoundFilterToJSON(compoundFilter: CompoundFilter): string {
  return JSON.stringify(CompoundFilter$outboundSchema.parse(compoundFilter));
}
export function compoundFilterFromJSON(
  jsonString: string,
): SafeParseResult<CompoundFilter, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => CompoundFilter$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'CompoundFilter' from JSON`,
  );
}

/** @internal */
export const Filters$inboundSchema: z.ZodType<Filters, z.ZodTypeDef, unknown> =
  z.union([
    ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("eq") })),
    ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("ne") })),
    ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("gt") })),
    ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("gte") })),
    ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("lt") })),
    ComparisonFilter$inboundSchema.and(z.object({ type: z.literal("lte") })),
    z.lazy(() => CompoundFilter$inboundSchema).and(
      z.object({ type: z.literal("and") }),
    ),
    z.lazy(() => CompoundFilter$inboundSchema).and(
      z.object({ type: z.literal("or") }),
    ),
  ]);
/** @internal */
export type Filters$Outbound =
  | (ComparisonFilter$Outbound & { type: "eq" })
  | (ComparisonFilter$Outbound & { type: "ne" })
  | (ComparisonFilter$Outbound & { type: "gt" })
  | (ComparisonFilter$Outbound & { type: "gte" })
  | (ComparisonFilter$Outbound & { type: "lt" })
  | (ComparisonFilter$Outbound & { type: "lte" })
  | (CompoundFilter$Outbound & { type: "and" })
  | (CompoundFilter$Outbound & { type: "or" });

/** @internal */
export const Filters$outboundSchema: z.ZodType<
  Filters$Outbound,
  z.ZodTypeDef,
  Filters
> = z.union([
  ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("eq") })),
  ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("ne") })),
  ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("gt") })),
  ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("gte") })),
  ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("lt") })),
  ComparisonFilter$outboundSchema.and(z.object({ type: z.literal("lte") })),
  z.lazy(() => CompoundFilter$outboundSchema).and(
    z.object({ type: z.literal("and") }),
  ),
  z.lazy(() => CompoundFilter$outboundSchema).and(
    z.object({ type: z.literal("or") }),
  ),
]);

export function filtersToJSON(filters: Filters): string {
  return JSON.stringify(Filters$outboundSchema.parse(filters));
}
export function filtersFromJSON(
  jsonString: string,
): SafeParseResult<Filters, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => Filters$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'Filters' from JSON`,
  );
}