/*
 * 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 { SDKValidationError } from "./sdkvalidationerror.js";

export type GetFlagSettingsRequest = {
  /**
   * The project id or name
   */
  projectIdOrName: string;
  /**
   * 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 GetFlagSettingsTypeName = {
  Settings: "settings",
} as const;
export type GetFlagSettingsTypeName = ClosedEnum<
  typeof GetFlagSettingsTypeName
>;

export type Connections = {
  edgeConfigId: string;
  edgeConfigItemKey: string;
};

export type GetFlagSettingsLabels = {
  label: string;
  value: string;
};

export type GetFlagSettingsAttributes = {
  key: string;
  type: string;
  labels?: Array<GetFlagSettingsLabels> | undefined;
};

export type GetFlagSettingsEntities = {
  kind: string;
  label: string;
  attributes: Array<GetFlagSettingsAttributes>;
};

export type GetFlagSettingsMetadata = {
  activeFlagCount: number;
  archivedFlagCount: number;
  segmentCount: number;
  packSizeInBytes: number;
  packRevision?: number | undefined;
  configUpdatedAt?: number | undefined;
};

/**
 * Syncs direct the synchronization of Flags to Edge Configs
 */
export type GetFlagSettingsResponseBody = {
  typeName: GetFlagSettingsTypeName;
  projectId: string;
  ownerId?: string | undefined;
  enabled: boolean;
  environments: Array<string>;
  connections?: Array<Connections> | undefined;
  entities: Array<GetFlagSettingsEntities>;
  createdAt?: number | undefined;
  updatedAt?: number | undefined;
  metadata: GetFlagSettingsMetadata;
};

/** @internal */
export type GetFlagSettingsRequest$Outbound = {
  projectIdOrName: string;
  teamId?: string | undefined;
  slug?: string | undefined;
};

/** @internal */
export const GetFlagSettingsRequest$outboundSchema: z.ZodType<
  GetFlagSettingsRequest$Outbound,
  z.ZodTypeDef,
  GetFlagSettingsRequest
> = z.object({
  projectIdOrName: z.string(),
  teamId: z.string().optional(),
  slug: z.string().optional(),
});

export function getFlagSettingsRequestToJSON(
  getFlagSettingsRequest: GetFlagSettingsRequest,
): string {
  return JSON.stringify(
    GetFlagSettingsRequest$outboundSchema.parse(getFlagSettingsRequest),
  );
}

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

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

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

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

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

/** @internal */
export const GetFlagSettingsAttributes$inboundSchema: z.ZodType<
  GetFlagSettingsAttributes,
  z.ZodTypeDef,
  unknown
> = z.object({
  key: types.string(),
  type: types.string(),
  labels: types.optional(
    z.array(z.lazy(() => GetFlagSettingsLabels$inboundSchema)),
  ),
});

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

/** @internal */
export const GetFlagSettingsEntities$inboundSchema: z.ZodType<
  GetFlagSettingsEntities,
  z.ZodTypeDef,
  unknown
> = z.object({
  kind: types.string(),
  label: types.string(),
  attributes: z.array(z.lazy(() => GetFlagSettingsAttributes$inboundSchema)),
});

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

/** @internal */
export const GetFlagSettingsMetadata$inboundSchema: z.ZodType<
  GetFlagSettingsMetadata,
  z.ZodTypeDef,
  unknown
> = z.object({
  activeFlagCount: types.number(),
  archivedFlagCount: types.number(),
  segmentCount: types.number(),
  packSizeInBytes: types.number(),
  packRevision: types.optional(types.number()),
  configUpdatedAt: types.optional(types.number()),
});

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

/** @internal */
export const GetFlagSettingsResponseBody$inboundSchema: z.ZodType<
  GetFlagSettingsResponseBody,
  z.ZodTypeDef,
  unknown
> = z.object({
  typeName: GetFlagSettingsTypeName$inboundSchema,
  projectId: types.string(),
  ownerId: types.optional(types.string()),
  enabled: types.boolean(),
  environments: z.array(types.string()),
  connections: types.optional(z.array(z.lazy(() => Connections$inboundSchema))),
  entities: z.array(z.lazy(() => GetFlagSettingsEntities$inboundSchema)),
  createdAt: types.optional(types.number()),
  updatedAt: types.optional(types.number()),
  metadata: z.lazy(() => GetFlagSettingsMetadata$inboundSchema),
});

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