/*
 * 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 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 type ListFlagVersionsFallthrough4 = {
  type: "experiment";
};

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 ListFlagVersionsFallthroughFeatureFlagsResponse200ApplicationJSONResponseBodyType =
  {
    Entity: "entity",
  } as const;
export type ListFlagVersionsFallthroughFeatureFlagsResponse200ApplicationJSONResponseBodyType =
  ClosedEnum<
    typeof ListFlagVersionsFallthroughFeatureFlagsResponse200ApplicationJSONResponseBodyType
  >;

export type ListFlagVersionsFallthroughBase = {
  type:
    ListFlagVersionsFallthroughFeatureFlagsResponse200ApplicationJSONResponseBodyType;
  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
  | ListFlagVersionsFallthrough4;

export type ListFlagVersionsOutcome4 = {
  type: "experiment";
};

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 ListFlagVersionsOutcomeFeatureFlagsResponse200ApplicationJSONResponseBodyType =
  {
    Entity: "entity",
  } as const;
export type ListFlagVersionsOutcomeFeatureFlagsResponse200ApplicationJSONResponseBodyType =
  ClosedEnum<
    typeof ListFlagVersionsOutcomeFeatureFlagsResponse200ApplicationJSONResponseBodyType
  >;

export type ListFlagVersionsOutcomeBase = {
  type:
    ListFlagVersionsOutcomeFeatureFlagsResponse200ApplicationJSONResponseBodyType;
  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
  | ListFlagVersionsOutcome4;

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
    | ListFlagVersionsOutcome4;
  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
    | ListFlagVersionsFallthrough4;
  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;
  variants: Array<ListFlagVersionsVariants>;
  environments: { [k: string]: ListFlagVersionsEnvironments };
  seed: number;
  state: ListFlagVersionsState;
  maintainerIds?: Array<string> | undefined;
  permanent?: boolean | undefined;
  tags?: Array<string> | undefined;
};

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

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

export type ListFlagVersionsVersions = {
  id: string;
  revision: number;
  createdAt: number;
  createdBy?: string | undefined;
  message?: string | undefined;
  flagId: string;
  changedEnvironments: Array<string>;
  data: ListFlagVersionsData;
  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 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 ListFlagVersionsFallthrough4$inboundSchema: z.ZodType<
  ListFlagVersionsFallthrough4,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("experiment"),
});

export function listFlagVersionsFallthrough4FromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsFallthrough4, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsFallthrough4$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsFallthrough4' 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 ListFlagVersionsFallthroughFeatureFlagsResponse200ApplicationJSONResponseBodyType$inboundSchema:
  z.ZodNativeEnum<
    typeof ListFlagVersionsFallthroughFeatureFlagsResponse200ApplicationJSONResponseBodyType
  > = z.nativeEnum(
    ListFlagVersionsFallthroughFeatureFlagsResponse200ApplicationJSONResponseBodyType,
  );

/** @internal */
export const ListFlagVersionsFallthroughBase$inboundSchema: z.ZodType<
  ListFlagVersionsFallthroughBase,
  z.ZodTypeDef,
  unknown
> = z.object({
  type:
    ListFlagVersionsFallthroughFeatureFlagsResponse200ApplicationJSONResponseBodyType$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),
  z.lazy(() => ListFlagVersionsFallthrough4$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 ListFlagVersionsOutcome4$inboundSchema: z.ZodType<
  ListFlagVersionsOutcome4,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: types.literal("experiment"),
});

export function listFlagVersionsOutcome4FromJSON(
  jsonString: string,
): SafeParseResult<ListFlagVersionsOutcome4, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListFlagVersionsOutcome4$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListFlagVersionsOutcome4' 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 ListFlagVersionsOutcomeFeatureFlagsResponse200ApplicationJSONResponseBodyType$inboundSchema:
  z.ZodNativeEnum<
    typeof ListFlagVersionsOutcomeFeatureFlagsResponse200ApplicationJSONResponseBodyType
  > = z.nativeEnum(
    ListFlagVersionsOutcomeFeatureFlagsResponse200ApplicationJSONResponseBodyType,
  );

/** @internal */
export const ListFlagVersionsOutcomeBase$inboundSchema: z.ZodType<
  ListFlagVersionsOutcomeBase,
  z.ZodTypeDef,
  unknown
> = z.object({
  type:
    ListFlagVersionsOutcomeFeatureFlagsResponse200ApplicationJSONResponseBodyType$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),
  z.lazy(() => ListFlagVersionsOutcome4$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),
    z.lazy(() => ListFlagVersionsOutcome4$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),
    z.lazy(() => ListFlagVersionsFallthrough4$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()),
  variants: z.array(z.lazy(() => ListFlagVersionsVariants$inboundSchema)),
  environments: z.record(
    z.lazy(() => ListFlagVersionsEnvironments$inboundSchema),
  ),
  seed: types.number(),
  state: ListFlagVersionsState$inboundSchema,
  maintainerIds: types.optional(z.array(types.string())),
  permanent: types.optional(types.boolean()),
  tags: types.optional(z.array(types.string())),
});

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({
  id: types.string(),
  revision: types.number(),
  createdAt: types.number(),
  createdBy: types.optional(types.string()),
  message: types.optional(types.string()),
  flagId: types.string(),
  changedEnvironments: z.array(types.string()),
  data: z.lazy(() => ListFlagVersionsData$inboundSchema),
  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`,
  );
}