/*
 * 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 * as types from "../types/primitives.js";
import { smartUnion } from "../types/smartUnion.js";
import { SDKValidationError } from "./sdkvalidationerror.js";

export type ListFlagVersionsRequest = {
  projectIdOrName: string;
  flagIdOrSlug: string;
  limit?: number | undefined;
  /**
   * Pagination cursor
   */
  cursor?: string | undefined;
  /**
   * Environment to filter by
   */
  environment?: string | undefined;
  /**
   * Whether to include metadata
   */
  withMetadata?: boolean | undefined;
  /**
   * The Team identifier to perform the request on behalf of.
   */
  teamId?: string | undefined;
  /**
   * The Team slug to perform the request on behalf of.
   */
  slug?: string | undefined;
};

export const ListFlagVersionsMetricType = {
  Count: "count",
  Currency: "currency",
  Percentage: "percentage",
} as const;
export type ListFlagVersionsMetricType = ClosedEnum<
  typeof ListFlagVersionsMetricType
>;

export const ListFlagVersionsMetricUnit = {
  Session: "session",
  User: "user",
  Visitor: "visitor",
} as const;
export type ListFlagVersionsMetricUnit = ClosedEnum<
  typeof ListFlagVersionsMetricUnit
>;

export const ListFlagVersionsDirectionality = {
  DecreaseIsGood: "decreaseIsGood",
  IncreaseIsGood: "increaseIsGood",
} as const;
export type ListFlagVersionsDirectionality = ClosedEnum<
  typeof ListFlagVersionsDirectionality
>;

export type ListFlagVersionsGuardrailMetrics = {
  description?: string | undefined;
  metricFormula?: string | undefined;
  name: string;
  metricType: ListFlagVersionsMetricType;
  metricUnit: ListFlagVersionsMetricUnit;
  directionality: ListFlagVersionsDirectionality;
};

export const ListFlagVersionsDevice = {
  Android: "android",
  Desktop: "desktop",
  Ios: "ios",
  Mweb: "mweb",
} as const;
export type ListFlagVersionsDevice = ClosedEnum<typeof ListFlagVersionsDevice>;

export const ListFlagVersionsDurationUnit = {
  Days: "days",
  Exposures: "exposures",
} as const;
export type ListFlagVersionsDurationUnit = ClosedEnum<
  typeof ListFlagVersionsDurationUnit
>;

export const ListFlagVersionsAllocationUnit = {
  CookieId: "cookieId",
  UserId: "userId",
  VisitorId: "visitorId",
} as const;
export type ListFlagVersionsAllocationUnit = ClosedEnum<
  typeof ListFlagVersionsAllocationUnit
>;

export const ListFlagVersionsFeatureFlagsMetricType = {
  Count: "count",
  Currency: "currency",
  Percentage: "percentage",
} as const;
export type ListFlagVersionsFeatureFlagsMetricType = ClosedEnum<
  typeof ListFlagVersionsFeatureFlagsMetricType
>;

export const ListFlagVersionsFeatureFlagsMetricUnit = {
  Session: "session",
  User: "user",
  Visitor: "visitor",
} as const;
export type ListFlagVersionsFeatureFlagsMetricUnit = ClosedEnum<
  typeof ListFlagVersionsFeatureFlagsMetricUnit
>;

export const ListFlagVersionsFeatureFlagsDirectionality = {
  DecreaseIsGood: "decreaseIsGood",
  IncreaseIsGood: "increaseIsGood",
} as const;
export type ListFlagVersionsFeatureFlagsDirectionality = ClosedEnum<
  typeof ListFlagVersionsFeatureFlagsDirectionality
>;

export type ListFlagVersionsPrimaryMetrics = {
  description?: string | undefined;
  metricFormula?: string | undefined;
  name: string;
  metricType: ListFlagVersionsFeatureFlagsMetricType;
  metricUnit: ListFlagVersionsFeatureFlagsMetricUnit;
  directionality: ListFlagVersionsFeatureFlagsDirectionality;
};

export const ListFlagVersionsStatus = {
  Closed: "closed",
  Draft: "draft",
  Paused: "paused",
  Running: "running",
} as const;
export type ListFlagVersionsStatus = ClosedEnum<typeof ListFlagVersionsStatus>;

export type ListFlagVersionsExperiment = {
  id?: string | undefined;
  name?: string | undefined;
  numVariants?: number | undefined;
  surfaceArea?: string | undefined;
  stickyRequirement?: boolean | undefined;
  layer?: string | undefined;
  guardrailMetrics?: Array<ListFlagVersionsGuardrailMetrics> | undefined;
  hypothesis?: string | undefined;
  device?: ListFlagVersionsDevice | undefined;
  controlVariantId?: string | undefined;
  startedAt?: number | undefined;
  endedAt?: number | undefined;
  decision?: string | undefined;
  decisionReason?: string | undefined;
  duration?: number | undefined;
  durationUnit?: ListFlagVersionsDurationUnit | undefined;
  allocationPercent?: number | undefined;
  allocationUnit: ListFlagVersionsAllocationUnit;
  primaryMetrics: Array<ListFlagVersionsPrimaryMetrics>;
  status: ListFlagVersionsStatus;
};

export type ListFlagVersionsVariants = {};

export type ListFlagVersionsReuse = {
  active: boolean;
  environment: string;
};

export type ListFlagVersionsTargets = {
  note?: string | undefined;
  value: string;
};

export const ListFlagVersionsType = {
  Variant: "variant",
} as const;
export type ListFlagVersionsType = ClosedEnum<typeof ListFlagVersionsType>;

export type ListFlagVersionsPausedOutcome = {
  type: ListFlagVersionsType;
  variantId: string;
};

export const ListFlagVersionsFallthroughFeatureFlagsResponse200ApplicationJSONType =
  {
    Entity: "entity",
  } as const;
export type ListFlagVersionsFallthroughFeatureFlagsResponse200ApplicationJSONType =
  ClosedEnum<
    typeof ListFlagVersionsFallthroughFeatureFlagsResponse200ApplicationJSONType
  >;

export type ListFlagVersionsFallthroughFeatureFlagsBase = {
  type: ListFlagVersionsFallthroughFeatureFlagsResponse200ApplicationJSONType;
  kind: string;
  attribute: string;
};

export type ListFlagVersionsFallthroughSlots = {
  promille: number;
  durationMs: number;
};

export type ListFlagVersionsFallthrough3 = {
  type: "rollout";
  base: ListFlagVersionsFallthroughFeatureFlagsBase;
  defaultVariantId: string;
  startTimestamp: number;
  rollFromVariantId: string;
  rollToVariantId: string;
  slots: Array<ListFlagVersionsFallthroughSlots>;
};

export const ListFlagVersionsFallthroughFeatureFlagsResponse200Type = {
  Entity: "entity",
} as const;
export type ListFlagVersionsFallthroughFeatureFlagsResponse200Type = ClosedEnum<
  typeof ListFlagVersionsFallthroughFeatureFlagsResponse200Type
>;

export type ListFlagVersionsFallthroughBase = {
  type: ListFlagVersionsFallthroughFeatureFlagsResponse200Type;
  kind: string;
  attribute: string;
};

export type ListFlagVersionsFallthrough2 = {
  type: "split";
  base: ListFlagVersionsFallthroughBase;
  weights: { [k: string]: number };
  defaultVariantId: string;
};

export type ListFlagVersionsFallthrough1 = {
  type: "variant";
  variantId: string;
};

export type ListFlagVersionsFallthrough =
  | ListFlagVersionsFallthrough1
  | ListFlagVersionsFallthrough2
  | ListFlagVersionsFallthrough3;

export const ListFlagVersionsOutcomeFeatureFlagsResponse200ApplicationJSONType =
  {
    Entity: "entity",
  } as const;
export type ListFlagVersionsOutcomeFeatureFlagsResponse200ApplicationJSONType =
  ClosedEnum<
    typeof ListFlagVersionsOutcomeFeatureFlagsResponse200ApplicationJSONType
  >;

export type ListFlagVersionsOutcomeFeatureFlagsBase = {
  type: ListFlagVersionsOutcomeFeatureFlagsResponse200ApplicationJSONType;
  kind: string;
  attribute: string;
};

export type ListFlagVersionsOutcomeSlots = {
  promille: number;
  durationMs: number;
};

export type ListFlagVersionsOutcome3 = {
  type: "rollout";
  base: ListFlagVersionsOutcomeFeatureFlagsBase;
  defaultVariantId: string;
  startTimestamp: number;
  rollFromVariantId: string;
  rollToVariantId: string;
  slots: Array<ListFlagVersionsOutcomeSlots>;
};

export const ListFlagVersionsOutcomeFeatureFlagsResponse200Type = {
  Entity: "entity",
} as const;
export type ListFlagVersionsOutcomeFeatureFlagsResponse200Type = ClosedEnum<
  typeof ListFlagVersionsOutcomeFeatureFlagsResponse200Type
>;

export type ListFlagVersionsOutcomeBase = {
  type: ListFlagVersionsOutcomeFeatureFlagsResponse200Type;
  kind: string;
  attribute: string;
};

export type ListFlagVersionsOutcome2 = {
  type: "split";
  base: ListFlagVersionsOutcomeBase;
  weights: { [k: string]: number };
  defaultVariantId: string;
};

export type ListFlagVersionsOutcome1 = {
  type: "variant";
  variantId: string;
};

export type ListFlagVersionsOutcome =
  | ListFlagVersionsOutcome1
  | ListFlagVersionsOutcome2
  | ListFlagVersionsOutcome3;

export const ListFlagVersionsRhsFeatureFlagsType = {
  Regex: "regex",
} as const;
export type ListFlagVersionsRhsFeatureFlagsType = ClosedEnum<
  typeof ListFlagVersionsRhsFeatureFlagsType
>;

export type ListFlagVersionsRhs4 = {
  type: ListFlagVersionsRhsFeatureFlagsType;
  pattern: string;
  flags: string;
};

export const ListFlagVersionsRhsType = {
  List: "list",
  ListInline: "list/inline",
} as const;
export type ListFlagVersionsRhsType = ClosedEnum<
  typeof ListFlagVersionsRhsType
>;

export type ListFlagVersionsItems2 = {
  label?: string | undefined;
  note?: string | undefined;
  value: string;
};

export type ListFlagVersionsItems1 = {
  label?: string | undefined;
  note?: string | undefined;
  value: number;
};

export type ListFlagVersionsRhsItems =
  | ListFlagVersionsItems1
  | ListFlagVersionsItems2;

export type ListFlagVersionsRhs3 = {
  type: ListFlagVersionsRhsType;
  items: Array<ListFlagVersionsItems1 | ListFlagVersionsItems2>;
};

export type ListFlagVersionsRhs =
  | ListFlagVersionsRhs4
  | ListFlagVersionsRhs3
  | string
  | number
  | boolean;

export type ListFlagVersionsCmpOptions = {
  ignoreCase?: boolean | undefined;
};

export type ListFlagVersionsLhs2 = {
  type: "entity";
  kind: string;
  attribute: string;
};

export type ListFlagVersionsLhs1 = {
  type: "segment";
};

export type ListFlagVersionsLhs = ListFlagVersionsLhs1 | ListFlagVersionsLhs2;

export const ListFlagVersionsCmp = {
  NotContains: "!contains",
  NotEndsWith: "!endsWith",
  NotEq: "!eq",
  NotEx: "!ex",
  NotOneOf: "!oneOf",
  NotRegex: "!regex",
  NotStartsWith: "!startsWith",
  After: "after",
  Before: "before",
  Contains: "contains",
  ContainsAllOf: "containsAllOf",
  ContainsAnyOf: "containsAnyOf",
  ContainsNoneOf: "containsNoneOf",
  EndsWith: "endsWith",
  Eq: "eq",
  Ex: "ex",
  Gt: "gt",
  Gte: "gte",
  Lt: "lt",
  Lte: "lte",
  OneOf: "oneOf",
  Regex: "regex",
  StartsWith: "startsWith",
} as const;
export type ListFlagVersionsCmp = ClosedEnum<typeof ListFlagVersionsCmp>;

export type ListFlagVersionsConditions = {
  rhs?:
    | ListFlagVersionsRhs4
    | ListFlagVersionsRhs3
    | string
    | number
    | boolean
    | undefined;
  cmpOptions?: ListFlagVersionsCmpOptions | undefined;
  lhs: ListFlagVersionsLhs1 | ListFlagVersionsLhs2;
  cmp: ListFlagVersionsCmp;
};

export type ListFlagVersionsRules = {
  id: string;
  outcome:
    | ListFlagVersionsOutcome1
    | ListFlagVersionsOutcome2
    | ListFlagVersionsOutcome3;
  conditions: Array<ListFlagVersionsConditions>;
};

export type ListFlagVersionsEnvironments = {
  reuse?: ListFlagVersionsReuse | undefined;
  targets?: {
    [k: string]: {
      [k: string]: { [k: string]: Array<ListFlagVersionsTargets> };
    };
  } | undefined;
  revision?: number | undefined;
  pausedOutcome: ListFlagVersionsPausedOutcome;
  fallthrough:
    | ListFlagVersionsFallthrough1
    | ListFlagVersionsFallthrough2
    | ListFlagVersionsFallthrough3;
  active: boolean;
  rules: Array<ListFlagVersionsRules>;
};

export const ListFlagVersionsState = {
  Active: "active",
  Archived: "archived",
} as const;
export type ListFlagVersionsState = ClosedEnum<typeof ListFlagVersionsState>;

export type ListFlagVersionsData = {
  description?: string | undefined;
  maintainerIds?: Array<string> | undefined;
  permanent?: boolean | undefined;
  tags?: Array<string> | undefined;
  experiment?: ListFlagVersionsExperiment | undefined;
  variants: Array<ListFlagVersionsVariants>;
  environments: { [k: string]: ListFlagVersionsEnvironments };
  seed: number;
  state: ListFlagVersionsState;
};

export type ListFlagVersionsCreator = {
  id: string;
  name: string;
};

export type ListFlagVersionsMetadata = {
  creator?: ListFlagVersionsCreator | undefined;
};

export type ListFlagVersionsVersions = {
  createdBy?: string | undefined;
  message?: string | undefined;
  data: ListFlagVersionsData;
  id: string;
  revision: number;
  createdAt: number;
  flagId: string;
  changedEnvironments: Array<string>;
  metadata?: ListFlagVersionsMetadata | undefined;
};

export type ListFlagVersionsPagination = {};

export type ListFlagVersionsResponseBody = {
  versions: Array<ListFlagVersionsVersions>;
  pagination: ListFlagVersionsPagination;
};

/** @internal */
export type ListFlagVersionsRequest$Outbound = {
  projectIdOrName: string;
  flagIdOrSlug: string;
  limit: number;
  cursor?: string | undefined;
  environment?: string | undefined;
  withMetadata: boolean;
  teamId?: string | undefined;
  slug?: string | undefined;
};

/** @internal */
export const ListFlagVersionsRequest$outboundSchema: z.ZodType<
  ListFlagVersionsRequest$Outbound,
  z.ZodTypeDef,
  ListFlagVersionsRequest
> = z.object({
  projectIdOrName: z.string(),
  flagIdOrSlug: z.string(),
  limit: z.number().default(20),
  cursor: z.string().optional(),
  environment: z.string().optional(),
  withMetadata: z.boolean().default(false),
  teamId: z.string().optional(),
  slug: z.string().optional(),
});

export function listFlagVersionsRequestToJSON(
  listFlagVersionsRequest: ListFlagVersionsRequest,
): string {
  return JSON.stringify(
    ListFlagVersionsRequest$outboundSchema.parse(listFlagVersionsRequest),
  );
}

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

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

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

/** @internal */
export const ListFlagVersionsGuardrailMetrics$inboundSchema: z.ZodType<
  ListFlagVersionsGuardrailMetrics,
  z.ZodTypeDef,
  unknown
> = z.object({
  description: types.optional(types.string()),
  metricFormula: types.optional(types.string()),
  name: types.string(),
  metricType: ListFlagVersionsMetricType$inboundSchema,
  metricUnit: ListFlagVersionsMetricUnit$inboundSchema,
  directionality: ListFlagVersionsDirectionality$inboundSchema,
});

export function listFlagVersionsGuardrailMetricsFromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsGuardrailMetrics, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsGuardrailMetrics$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsGuardrailMetrics' from JSON`,
  );
}

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

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

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

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

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

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

/** @internal */
export const ListFlagVersionsPrimaryMetrics$inboundSchema: z.ZodType<
  ListFlagVersionsPrimaryMetrics,
  z.ZodTypeDef,
  unknown
> = z.object({
  description: types.optional(types.string()),
  metricFormula: types.optional(types.string()),
  name: types.string(),
  metricType: ListFlagVersionsFeatureFlagsMetricType$inboundSchema,
  metricUnit: ListFlagVersionsFeatureFlagsMetricUnit$inboundSchema,
  directionality: ListFlagVersionsFeatureFlagsDirectionality$inboundSchema,
});

export function listFlagVersionsPrimaryMetricsFromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsPrimaryMetrics, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsPrimaryMetrics$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsPrimaryMetrics' from JSON`,
  );
}

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

/** @internal */
export const ListFlagVersionsExperiment$inboundSchema: z.ZodType<
  ListFlagVersionsExperiment,
  z.ZodTypeDef,
  unknown
> = z.object({
  id: types.optional(types.string()),
  name: types.optional(types.string()),
  numVariants: types.optional(types.number()),
  surfaceArea: types.optional(types.string()),
  stickyRequirement: types.optional(types.boolean()),
  layer: types.optional(types.string()),
  guardrailMetrics: types.optional(
    z.array(z.lazy(() => ListFlagVersionsGuardrailMetrics$inboundSchema)),
  ),
  hypothesis: types.optional(types.string()),
  device: types.optional(ListFlagVersionsDevice$inboundSchema),
  controlVariantId: types.optional(types.string()),
  startedAt: types.optional(types.number()),
  endedAt: types.optional(types.number()),
  decision: types.optional(types.string()),
  decisionReason: types.optional(types.string()),
  duration: types.optional(types.number()),
  durationUnit: types.optional(ListFlagVersionsDurationUnit$inboundSchema),
  allocationPercent: types.optional(types.number()),
  allocationUnit: ListFlagVersionsAllocationUnit$inboundSchema,
  primaryMetrics: z.array(
    z.lazy(() => ListFlagVersionsPrimaryMetrics$inboundSchema),
  ),
  status: ListFlagVersionsStatus$inboundSchema,
});

export function listFlagVersionsExperimentFromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsExperiment, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsExperiment$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsExperiment' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsVariants$inboundSchema: z.ZodType<
  ListFlagVersionsVariants,
  z.ZodTypeDef,
  unknown
> = z.object({});

export function listFlagVersionsVariantsFromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsVariants, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsVariants$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsVariants' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsReuse$inboundSchema: z.ZodType<
  ListFlagVersionsReuse,
  z.ZodTypeDef,
  unknown
> = z.object({
  active: types.boolean(),
  environment: types.string(),
});

export function listFlagVersionsReuseFromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsReuse, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsReuse$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsReuse' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsTargets$inboundSchema: z.ZodType<
  ListFlagVersionsTargets,
  z.ZodTypeDef,
  unknown
> = z.object({
  note: types.optional(types.string()),
  value: types.string(),
});

export function listFlagVersionsTargetsFromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsTargets, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsTargets$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsTargets' from JSON`,
  );
}

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

/** @internal */
export const ListFlagVersionsPausedOutcome$inboundSchema: z.ZodType<
  ListFlagVersionsPausedOutcome,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: ListFlagVersionsType$inboundSchema,
  variantId: types.string(),
});

export function listFlagVersionsPausedOutcomeFromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsPausedOutcome, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsPausedOutcome$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsPausedOutcome' from JSON`,
  );
}

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

/** @internal */
export const ListFlagVersionsFallthroughFeatureFlagsBase$inboundSchema:
  z.ZodType<
    ListFlagVersionsFallthroughFeatureFlagsBase,
    z.ZodTypeDef,
    unknown
  > = z.object({
    type:
      ListFlagVersionsFallthroughFeatureFlagsResponse200ApplicationJSONType$inboundSchema,
    kind: types.string(),
    attribute: types.string(),
  });

export function listFlagVersionsFallthroughFeatureFlagsBaseFromJSON(
  jsonString: string,
): SafeParseResult<
  ListFlagVersionsFallthroughFeatureFlagsBase,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      ListFlagVersionsFallthroughFeatureFlagsBase$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'ListFlagVersionsFallthroughFeatureFlagsBase' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsFallthroughSlots$inboundSchema: z.ZodType<
  ListFlagVersionsFallthroughSlots,
  z.ZodTypeDef,
  unknown
> = z.object({
  promille: types.number(),
  durationMs: types.number(),
});

export function listFlagVersionsFallthroughSlotsFromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsFallthroughSlots, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsFallthroughSlots$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsFallthroughSlots' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsFallthrough3$inboundSchema: z.ZodType<
  ListFlagVersionsFallthrough3,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("rollout"),
  base: z.lazy(() => ListFlagVersionsFallthroughFeatureFlagsBase$inboundSchema),
  defaultVariantId: types.string(),
  startTimestamp: types.number(),
  rollFromVariantId: types.string(),
  rollToVariantId: types.string(),
  slots: z.array(z.lazy(() => ListFlagVersionsFallthroughSlots$inboundSchema)),
});

export function listFlagVersionsFallthrough3FromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsFallthrough3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsFallthrough3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsFallthrough3' from JSON`,
  );
}

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

/** @internal */
export const ListFlagVersionsFallthroughBase$inboundSchema: z.ZodType<
  ListFlagVersionsFallthroughBase,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: ListFlagVersionsFallthroughFeatureFlagsResponse200Type$inboundSchema,
  kind: types.string(),
  attribute: types.string(),
});

export function listFlagVersionsFallthroughBaseFromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsFallthroughBase, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsFallthroughBase$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsFallthroughBase' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsFallthrough2$inboundSchema: z.ZodType<
  ListFlagVersionsFallthrough2,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("split"),
  base: z.lazy(() => ListFlagVersionsFallthroughBase$inboundSchema),
  weights: z.record(types.number()),
  defaultVariantId: types.string(),
});

export function listFlagVersionsFallthrough2FromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsFallthrough2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsFallthrough2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsFallthrough2' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsFallthrough1$inboundSchema: z.ZodType<
  ListFlagVersionsFallthrough1,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("variant"),
  variantId: types.string(),
});

export function listFlagVersionsFallthrough1FromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsFallthrough1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsFallthrough1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsFallthrough1' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsFallthrough$inboundSchema: z.ZodType<
  ListFlagVersionsFallthrough,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => ListFlagVersionsFallthrough1$inboundSchema),
  z.lazy(() => ListFlagVersionsFallthrough2$inboundSchema),
  z.lazy(() => ListFlagVersionsFallthrough3$inboundSchema),
]);

export function listFlagVersionsFallthroughFromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsFallthrough, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsFallthrough$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsFallthrough' from JSON`,
  );
}

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

/** @internal */
export const ListFlagVersionsOutcomeFeatureFlagsBase$inboundSchema: z.ZodType<
  ListFlagVersionsOutcomeFeatureFlagsBase,
  z.ZodTypeDef,
  unknown
> = z.object({
  type:
    ListFlagVersionsOutcomeFeatureFlagsResponse200ApplicationJSONType$inboundSchema,
  kind: types.string(),
  attribute: types.string(),
});

export function listFlagVersionsOutcomeFeatureFlagsBaseFromJSON(
  jsonString: string,
): SafeParseResult<
  ListFlagVersionsOutcomeFeatureFlagsBase,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      ListFlagVersionsOutcomeFeatureFlagsBase$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'ListFlagVersionsOutcomeFeatureFlagsBase' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsOutcomeSlots$inboundSchema: z.ZodType<
  ListFlagVersionsOutcomeSlots,
  z.ZodTypeDef,
  unknown
> = z.object({
  promille: types.number(),
  durationMs: types.number(),
});

export function listFlagVersionsOutcomeSlotsFromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsOutcomeSlots, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsOutcomeSlots$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsOutcomeSlots' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsOutcome3$inboundSchema: z.ZodType<
  ListFlagVersionsOutcome3,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("rollout"),
  base: z.lazy(() => ListFlagVersionsOutcomeFeatureFlagsBase$inboundSchema),
  defaultVariantId: types.string(),
  startTimestamp: types.number(),
  rollFromVariantId: types.string(),
  rollToVariantId: types.string(),
  slots: z.array(z.lazy(() => ListFlagVersionsOutcomeSlots$inboundSchema)),
});

export function listFlagVersionsOutcome3FromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsOutcome3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsOutcome3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsOutcome3' from JSON`,
  );
}

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

/** @internal */
export const ListFlagVersionsOutcomeBase$inboundSchema: z.ZodType<
  ListFlagVersionsOutcomeBase,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: ListFlagVersionsOutcomeFeatureFlagsResponse200Type$inboundSchema,
  kind: types.string(),
  attribute: types.string(),
});

export function listFlagVersionsOutcomeBaseFromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsOutcomeBase, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsOutcomeBase$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsOutcomeBase' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsOutcome2$inboundSchema: z.ZodType<
  ListFlagVersionsOutcome2,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("split"),
  base: z.lazy(() => ListFlagVersionsOutcomeBase$inboundSchema),
  weights: z.record(types.number()),
  defaultVariantId: types.string(),
});

export function listFlagVersionsOutcome2FromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsOutcome2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsOutcome2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsOutcome2' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsOutcome1$inboundSchema: z.ZodType<
  ListFlagVersionsOutcome1,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("variant"),
  variantId: types.string(),
});

export function listFlagVersionsOutcome1FromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsOutcome1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsOutcome1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsOutcome1' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsOutcome$inboundSchema: z.ZodType<
  ListFlagVersionsOutcome,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => ListFlagVersionsOutcome1$inboundSchema),
  z.lazy(() => ListFlagVersionsOutcome2$inboundSchema),
  z.lazy(() => ListFlagVersionsOutcome3$inboundSchema),
]);

export function listFlagVersionsOutcomeFromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsOutcome, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsOutcome$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsOutcome' from JSON`,
  );
}

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

/** @internal */
export const ListFlagVersionsRhs4$inboundSchema: z.ZodType<
  ListFlagVersionsRhs4,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: ListFlagVersionsRhsFeatureFlagsType$inboundSchema,
  pattern: types.string(),
  flags: types.string(),
});

export function listFlagVersionsRhs4FromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsRhs4, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsRhs4$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsRhs4' from JSON`,
  );
}

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

/** @internal */
export const ListFlagVersionsItems2$inboundSchema: z.ZodType<
  ListFlagVersionsItems2,
  z.ZodTypeDef,
  unknown
> = z.object({
  label: types.optional(types.string()),
  note: types.optional(types.string()),
  value: types.string(),
});

export function listFlagVersionsItems2FromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsItems2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsItems2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsItems2' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsItems1$inboundSchema: z.ZodType<
  ListFlagVersionsItems1,
  z.ZodTypeDef,
  unknown
> = z.object({
  label: types.optional(types.string()),
  note: types.optional(types.string()),
  value: types.number(),
});

export function listFlagVersionsItems1FromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsItems1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsItems1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsItems1' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsRhsItems$inboundSchema: z.ZodType<
  ListFlagVersionsRhsItems,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.lazy(() => ListFlagVersionsItems1$inboundSchema),
  z.lazy(() => ListFlagVersionsItems2$inboundSchema),
]);

export function listFlagVersionsRhsItemsFromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsRhsItems, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsRhsItems$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsRhsItems' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsRhs3$inboundSchema: z.ZodType<
  ListFlagVersionsRhs3,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: ListFlagVersionsRhsType$inboundSchema,
  items: z.array(
    smartUnion([
      z.lazy(() => ListFlagVersionsItems1$inboundSchema),
      z.lazy(() => ListFlagVersionsItems2$inboundSchema),
    ]),
  ),
});

export function listFlagVersionsRhs3FromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsRhs3, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsRhs3$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsRhs3' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsRhs$inboundSchema: z.ZodType<
  ListFlagVersionsRhs,
  z.ZodTypeDef,
  unknown
> = smartUnion([
  z.lazy(() => ListFlagVersionsRhs4$inboundSchema),
  z.lazy(() => ListFlagVersionsRhs3$inboundSchema),
  types.string(),
  types.number(),
  types.boolean(),
]);

export function listFlagVersionsRhsFromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsRhs, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsRhs$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsRhs' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsCmpOptions$inboundSchema: z.ZodType<
  ListFlagVersionsCmpOptions,
  z.ZodTypeDef,
  unknown
> = z.object({
  ignoreCase: types.optional(types.boolean()),
});

export function listFlagVersionsCmpOptionsFromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsCmpOptions, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsCmpOptions$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsCmpOptions' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsLhs2$inboundSchema: z.ZodType<
  ListFlagVersionsLhs2,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("entity"),
  kind: types.string(),
  attribute: types.string(),
});

export function listFlagVersionsLhs2FromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsLhs2, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsLhs2$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsLhs2' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsLhs1$inboundSchema: z.ZodType<
  ListFlagVersionsLhs1,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("segment"),
});

export function listFlagVersionsLhs1FromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsLhs1, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsLhs1$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsLhs1' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsLhs$inboundSchema: z.ZodType<
  ListFlagVersionsLhs,
  z.ZodTypeDef,
  unknown
> = z.union([
  z.lazy(() => ListFlagVersionsLhs1$inboundSchema),
  z.lazy(() => ListFlagVersionsLhs2$inboundSchema),
]);

export function listFlagVersionsLhsFromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsLhs, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsLhs$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsLhs' from JSON`,
  );
}

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

/** @internal */
export const ListFlagVersionsConditions$inboundSchema: z.ZodType<
  ListFlagVersionsConditions,
  z.ZodTypeDef,
  unknown
> = z.object({
  rhs: types.optional(
    smartUnion([
      z.lazy(() => ListFlagVersionsRhs4$inboundSchema),
      z.lazy(() => ListFlagVersionsRhs3$inboundSchema),
      types.string(),
      types.number(),
      types.boolean(),
    ]),
  ),
  cmpOptions: types.optional(
    z.lazy(() => ListFlagVersionsCmpOptions$inboundSchema),
  ),
  lhs: z.union([
    z.lazy(() => ListFlagVersionsLhs1$inboundSchema),
    z.lazy(() => ListFlagVersionsLhs2$inboundSchema),
  ]),
  cmp: ListFlagVersionsCmp$inboundSchema,
});

export function listFlagVersionsConditionsFromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsConditions, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsConditions$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsConditions' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsRules$inboundSchema: z.ZodType<
  ListFlagVersionsRules,
  z.ZodTypeDef,
  unknown
> = z.object({
  id: types.string(),
  outcome: z.union([
    z.lazy(() => ListFlagVersionsOutcome1$inboundSchema),
    z.lazy(() => ListFlagVersionsOutcome2$inboundSchema),
    z.lazy(() => ListFlagVersionsOutcome3$inboundSchema),
  ]),
  conditions: z.array(z.lazy(() => ListFlagVersionsConditions$inboundSchema)),
});

export function listFlagVersionsRulesFromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsRules, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsRules$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsRules' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsEnvironments$inboundSchema: z.ZodType<
  ListFlagVersionsEnvironments,
  z.ZodTypeDef,
  unknown
> = z.object({
  reuse: types.optional(z.lazy(() => ListFlagVersionsReuse$inboundSchema)),
  targets: types.optional(
    z.record(z.record(z.record(z.array(z.lazy(() =>
      ListFlagVersionsTargets$inboundSchema
    ))))),
  ),
  revision: types.optional(types.number()),
  pausedOutcome: z.lazy(() => ListFlagVersionsPausedOutcome$inboundSchema),
  fallthrough: z.union([
    z.lazy(() => ListFlagVersionsFallthrough1$inboundSchema),
    z.lazy(() => ListFlagVersionsFallthrough2$inboundSchema),
    z.lazy(() => ListFlagVersionsFallthrough3$inboundSchema),
  ]),
  active: types.boolean(),
  rules: z.array(z.lazy(() => ListFlagVersionsRules$inboundSchema)),
});

export function listFlagVersionsEnvironmentsFromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsEnvironments, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsEnvironments$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsEnvironments' from JSON`,
  );
}

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

/** @internal */
export const ListFlagVersionsData$inboundSchema: z.ZodType<
  ListFlagVersionsData,
  z.ZodTypeDef,
  unknown
> = z.object({
  description: types.optional(types.string()),
  maintainerIds: types.optional(z.array(types.string())),
  permanent: types.optional(types.boolean()),
  tags: types.optional(z.array(types.string())),
  experiment: types.optional(
    z.lazy(() => ListFlagVersionsExperiment$inboundSchema),
  ),
  variants: z.array(z.lazy(() => ListFlagVersionsVariants$inboundSchema)),
  environments: z.record(
    z.lazy(() => ListFlagVersionsEnvironments$inboundSchema),
  ),
  seed: types.number(),
  state: ListFlagVersionsState$inboundSchema,
});

export function listFlagVersionsDataFromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsData, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsData$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsData' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsCreator$inboundSchema: z.ZodType<
  ListFlagVersionsCreator,
  z.ZodTypeDef,
  unknown
> = z.object({
  id: types.string(),
  name: types.string(),
});

export function listFlagVersionsCreatorFromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsCreator, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsCreator$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsCreator' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsMetadata$inboundSchema: z.ZodType<
  ListFlagVersionsMetadata,
  z.ZodTypeDef,
  unknown
> = z.object({
  creator: types.optional(z.lazy(() => ListFlagVersionsCreator$inboundSchema)),
});

export function listFlagVersionsMetadataFromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsMetadata, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsMetadata$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsMetadata' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsVersions$inboundSchema: z.ZodType<
  ListFlagVersionsVersions,
  z.ZodTypeDef,
  unknown
> = z.object({
  createdBy: types.optional(types.string()),
  message: types.optional(types.string()),
  data: z.lazy(() => ListFlagVersionsData$inboundSchema),
  id: types.string(),
  revision: types.number(),
  createdAt: types.number(),
  flagId: types.string(),
  changedEnvironments: z.array(types.string()),
  metadata: types.optional(
    z.lazy(() => ListFlagVersionsMetadata$inboundSchema),
  ),
});

export function listFlagVersionsVersionsFromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsVersions, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsVersions$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsVersions' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsPagination$inboundSchema: z.ZodType<
  ListFlagVersionsPagination,
  z.ZodTypeDef,
  unknown
> = z.object({});

export function listFlagVersionsPaginationFromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsPagination, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsPagination$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsPagination' from JSON`,
  );
}

/** @internal */
export const ListFlagVersionsResponseBody$inboundSchema: z.ZodType<
  ListFlagVersionsResponseBody,
  z.ZodTypeDef,
  unknown
> = z.object({
  versions: z.array(z.lazy(() => ListFlagVersionsVersions$inboundSchema)),
  pagination: z.lazy(() => ListFlagVersionsPagination$inboundSchema),
});

export function listFlagVersionsResponseBodyFromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsResponseBody, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsResponseBody$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsResponseBody' from JSON`,
  );
}