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

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

/**
 * Monday schedule
 */
export type Monday = {
  /**
   * Day schedule enabled
   */
  isEnabled: boolean;
  /**
   * Hours
   */
  hours?: Array<TimeRangeDto> | undefined;
};

/**
 * Tuesday schedule
 */
export type Tuesday = {
  /**
   * Day schedule enabled
   */
  isEnabled: boolean;
  /**
   * Hours
   */
  hours?: Array<TimeRangeDto> | undefined;
};

/**
 * Wednesday schedule
 */
export type Wednesday = {
  /**
   * Day schedule enabled
   */
  isEnabled: boolean;
  /**
   * Hours
   */
  hours?: Array<TimeRangeDto> | undefined;
};

/**
 * Thursday schedule
 */
export type Thursday = {
  /**
   * Day schedule enabled
   */
  isEnabled: boolean;
  /**
   * Hours
   */
  hours?: Array<TimeRangeDto> | undefined;
};

/**
 * Friday schedule
 */
export type Friday = {
  /**
   * Day schedule enabled
   */
  isEnabled: boolean;
  /**
   * Hours
   */
  hours?: Array<TimeRangeDto> | undefined;
};

/**
 * Saturday schedule
 */
export type Saturday = {
  /**
   * Day schedule enabled
   */
  isEnabled: boolean;
  /**
   * Hours
   */
  hours?: Array<TimeRangeDto> | undefined;
};

/**
 * Sunday schedule
 */
export type Sunday = {
  /**
   * Day schedule enabled
   */
  isEnabled: boolean;
  /**
   * Hours
   */
  hours?: Array<TimeRangeDto> | undefined;
};

/**
 * Weekly schedule
 */
export type WeeklySchedule = {
  /**
   * Monday schedule
   */
  monday?: Monday | undefined;
  /**
   * Tuesday schedule
   */
  tuesday?: Tuesday | undefined;
  /**
   * Wednesday schedule
   */
  wednesday?: Wednesday | undefined;
  /**
   * Thursday schedule
   */
  thursday?: Thursday | undefined;
  /**
   * Friday schedule
   */
  friday?: Friday | undefined;
  /**
   * Saturday schedule
   */
  saturday?: Saturday | undefined;
  /**
   * Sunday schedule
   */
  sunday?: Sunday | undefined;
};

export type ScheduleDto = {
  /**
   * Schedule enabled
   */
  isEnabled: boolean;
  /**
   * Weekly schedule
   */
  weeklySchedule?: WeeklySchedule | undefined;
};

/** @internal */
export const Monday$inboundSchema: z.ZodType<Monday, z.ZodTypeDef, unknown> = z
  .object({
    isEnabled: z.boolean(),
    hours: z.array(TimeRangeDto$inboundSchema).optional(),
  });
/** @internal */
export type Monday$Outbound = {
  isEnabled: boolean;
  hours?: Array<TimeRangeDto$Outbound> | undefined;
};

/** @internal */
export const Monday$outboundSchema: z.ZodType<
  Monday$Outbound,
  z.ZodTypeDef,
  Monday
> = z.object({
  isEnabled: z.boolean(),
  hours: z.array(TimeRangeDto$outboundSchema).optional(),
});

export function mondayToJSON(monday: Monday): string {
  return JSON.stringify(Monday$outboundSchema.parse(monday));
}
export function mondayFromJSON(
  jsonString: string,
): SafeParseResult<Monday, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => Monday$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'Monday' from JSON`,
  );
}

/** @internal */
export const Tuesday$inboundSchema: z.ZodType<Tuesday, z.ZodTypeDef, unknown> =
  z.object({
    isEnabled: z.boolean(),
    hours: z.array(TimeRangeDto$inboundSchema).optional(),
  });
/** @internal */
export type Tuesday$Outbound = {
  isEnabled: boolean;
  hours?: Array<TimeRangeDto$Outbound> | undefined;
};

/** @internal */
export const Tuesday$outboundSchema: z.ZodType<
  Tuesday$Outbound,
  z.ZodTypeDef,
  Tuesday
> = z.object({
  isEnabled: z.boolean(),
  hours: z.array(TimeRangeDto$outboundSchema).optional(),
});

export function tuesdayToJSON(tuesday: Tuesday): string {
  return JSON.stringify(Tuesday$outboundSchema.parse(tuesday));
}
export function tuesdayFromJSON(
  jsonString: string,
): SafeParseResult<Tuesday, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => Tuesday$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'Tuesday' from JSON`,
  );
}

/** @internal */
export const Wednesday$inboundSchema: z.ZodType<
  Wednesday,
  z.ZodTypeDef,
  unknown
> = z.object({
  isEnabled: z.boolean(),
  hours: z.array(TimeRangeDto$inboundSchema).optional(),
});
/** @internal */
export type Wednesday$Outbound = {
  isEnabled: boolean;
  hours?: Array<TimeRangeDto$Outbound> | undefined;
};

/** @internal */
export const Wednesday$outboundSchema: z.ZodType<
  Wednesday$Outbound,
  z.ZodTypeDef,
  Wednesday
> = z.object({
  isEnabled: z.boolean(),
  hours: z.array(TimeRangeDto$outboundSchema).optional(),
});

export function wednesdayToJSON(wednesday: Wednesday): string {
  return JSON.stringify(Wednesday$outboundSchema.parse(wednesday));
}
export function wednesdayFromJSON(
  jsonString: string,
): SafeParseResult<Wednesday, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => Wednesday$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'Wednesday' from JSON`,
  );
}

/** @internal */
export const Thursday$inboundSchema: z.ZodType<
  Thursday,
  z.ZodTypeDef,
  unknown
> = z.object({
  isEnabled: z.boolean(),
  hours: z.array(TimeRangeDto$inboundSchema).optional(),
});
/** @internal */
export type Thursday$Outbound = {
  isEnabled: boolean;
  hours?: Array<TimeRangeDto$Outbound> | undefined;
};

/** @internal */
export const Thursday$outboundSchema: z.ZodType<
  Thursday$Outbound,
  z.ZodTypeDef,
  Thursday
> = z.object({
  isEnabled: z.boolean(),
  hours: z.array(TimeRangeDto$outboundSchema).optional(),
});

export function thursdayToJSON(thursday: Thursday): string {
  return JSON.stringify(Thursday$outboundSchema.parse(thursday));
}
export function thursdayFromJSON(
  jsonString: string,
): SafeParseResult<Thursday, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => Thursday$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'Thursday' from JSON`,
  );
}

/** @internal */
export const Friday$inboundSchema: z.ZodType<Friday, z.ZodTypeDef, unknown> = z
  .object({
    isEnabled: z.boolean(),
    hours: z.array(TimeRangeDto$inboundSchema).optional(),
  });
/** @internal */
export type Friday$Outbound = {
  isEnabled: boolean;
  hours?: Array<TimeRangeDto$Outbound> | undefined;
};

/** @internal */
export const Friday$outboundSchema: z.ZodType<
  Friday$Outbound,
  z.ZodTypeDef,
  Friday
> = z.object({
  isEnabled: z.boolean(),
  hours: z.array(TimeRangeDto$outboundSchema).optional(),
});

export function fridayToJSON(friday: Friday): string {
  return JSON.stringify(Friday$outboundSchema.parse(friday));
}
export function fridayFromJSON(
  jsonString: string,
): SafeParseResult<Friday, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => Friday$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'Friday' from JSON`,
  );
}

/** @internal */
export const Saturday$inboundSchema: z.ZodType<
  Saturday,
  z.ZodTypeDef,
  unknown
> = z.object({
  isEnabled: z.boolean(),
  hours: z.array(TimeRangeDto$inboundSchema).optional(),
});
/** @internal */
export type Saturday$Outbound = {
  isEnabled: boolean;
  hours?: Array<TimeRangeDto$Outbound> | undefined;
};

/** @internal */
export const Saturday$outboundSchema: z.ZodType<
  Saturday$Outbound,
  z.ZodTypeDef,
  Saturday
> = z.object({
  isEnabled: z.boolean(),
  hours: z.array(TimeRangeDto$outboundSchema).optional(),
});

export function saturdayToJSON(saturday: Saturday): string {
  return JSON.stringify(Saturday$outboundSchema.parse(saturday));
}
export function saturdayFromJSON(
  jsonString: string,
): SafeParseResult<Saturday, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => Saturday$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'Saturday' from JSON`,
  );
}

/** @internal */
export const Sunday$inboundSchema: z.ZodType<Sunday, z.ZodTypeDef, unknown> = z
  .object({
    isEnabled: z.boolean(),
    hours: z.array(TimeRangeDto$inboundSchema).optional(),
  });
/** @internal */
export type Sunday$Outbound = {
  isEnabled: boolean;
  hours?: Array<TimeRangeDto$Outbound> | undefined;
};

/** @internal */
export const Sunday$outboundSchema: z.ZodType<
  Sunday$Outbound,
  z.ZodTypeDef,
  Sunday
> = z.object({
  isEnabled: z.boolean(),
  hours: z.array(TimeRangeDto$outboundSchema).optional(),
});

export function sundayToJSON(sunday: Sunday): string {
  return JSON.stringify(Sunday$outboundSchema.parse(sunday));
}
export function sundayFromJSON(
  jsonString: string,
): SafeParseResult<Sunday, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => Sunday$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'Sunday' from JSON`,
  );
}

/** @internal */
export const WeeklySchedule$inboundSchema: z.ZodType<
  WeeklySchedule,
  z.ZodTypeDef,
  unknown
> = z.object({
  monday: z.lazy(() => Monday$inboundSchema).optional(),
  tuesday: z.lazy(() => Tuesday$inboundSchema).optional(),
  wednesday: z.lazy(() => Wednesday$inboundSchema).optional(),
  thursday: z.lazy(() => Thursday$inboundSchema).optional(),
  friday: z.lazy(() => Friday$inboundSchema).optional(),
  saturday: z.lazy(() => Saturday$inboundSchema).optional(),
  sunday: z.lazy(() => Sunday$inboundSchema).optional(),
});
/** @internal */
export type WeeklySchedule$Outbound = {
  monday?: Monday$Outbound | undefined;
  tuesday?: Tuesday$Outbound | undefined;
  wednesday?: Wednesday$Outbound | undefined;
  thursday?: Thursday$Outbound | undefined;
  friday?: Friday$Outbound | undefined;
  saturday?: Saturday$Outbound | undefined;
  sunday?: Sunday$Outbound | undefined;
};

/** @internal */
export const WeeklySchedule$outboundSchema: z.ZodType<
  WeeklySchedule$Outbound,
  z.ZodTypeDef,
  WeeklySchedule
> = z.object({
  monday: z.lazy(() => Monday$outboundSchema).optional(),
  tuesday: z.lazy(() => Tuesday$outboundSchema).optional(),
  wednesday: z.lazy(() => Wednesday$outboundSchema).optional(),
  thursday: z.lazy(() => Thursday$outboundSchema).optional(),
  friday: z.lazy(() => Friday$outboundSchema).optional(),
  saturday: z.lazy(() => Saturday$outboundSchema).optional(),
  sunday: z.lazy(() => Sunday$outboundSchema).optional(),
});

export function weeklyScheduleToJSON(weeklySchedule: WeeklySchedule): string {
  return JSON.stringify(WeeklySchedule$outboundSchema.parse(weeklySchedule));
}
export function weeklyScheduleFromJSON(
  jsonString: string,
): SafeParseResult<WeeklySchedule, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => WeeklySchedule$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'WeeklySchedule' from JSON`,
  );
}

/** @internal */
export const ScheduleDto$inboundSchema: z.ZodType<
  ScheduleDto,
  z.ZodTypeDef,
  unknown
> = z.object({
  isEnabled: z.boolean(),
  weeklySchedule: z.lazy(() => WeeklySchedule$inboundSchema).optional(),
});
/** @internal */
export type ScheduleDto$Outbound = {
  isEnabled: boolean;
  weeklySchedule?: WeeklySchedule$Outbound | undefined;
};

/** @internal */
export const ScheduleDto$outboundSchema: z.ZodType<
  ScheduleDto$Outbound,
  z.ZodTypeDef,
  ScheduleDto
> = z.object({
  isEnabled: z.boolean(),
  weeklySchedule: z.lazy(() => WeeklySchedule$outboundSchema).optional(),
});

export function scheduleDtoToJSON(scheduleDto: ScheduleDto): string {
  return JSON.stringify(ScheduleDto$outboundSchema.parse(scheduleDto));
}
export function scheduleDtoFromJSON(
  jsonString: string,
): SafeParseResult<ScheduleDto, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ScheduleDto$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ScheduleDto' from JSON`,
  );
}