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

import * as z from "zod/v3";
import { remap as remap$ } from "../lib/primitives.js";
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 Labels = {
  label: string;
  value: string;
};

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

export type UpdateFlagSettingsEntities = {
  kind: string;
  label: string;
  attributes: Array<Attributes>;
};

export type UpdateFlagSettingsRequestBody = {
  enabled?: boolean | undefined;
  entities?: Array<UpdateFlagSettingsEntities> | undefined;
  /**
   * The environments to sync
   */
  environments?: Array<string> | undefined;
};

export type UpdateFlagSettingsRequest = {
  /**
   * 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;
  requestBody?: UpdateFlagSettingsRequestBody | undefined;
};

export const UpdateFlagSettingsFeatureFlagsTypeName = {
  Settings: "settings",
} as const;
export type UpdateFlagSettingsFeatureFlagsTypeName = ClosedEnum<
  typeof UpdateFlagSettingsFeatureFlagsTypeName
>;

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

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

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

export type UpdateFlagSettingsFeatureFlagsResponseEntities = {
  kind: string;
  label: string;
  attributes: Array<UpdateFlagSettingsFeatureFlagsAttributes>;
};

export type UpdateFlagSettingsFeatureFlagsMetadata = {
  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 UpdateFlagSettingsFeatureFlagsResponseBody = {
  typeName: UpdateFlagSettingsFeatureFlagsTypeName;
  projectId: string;
  ownerId?: string | undefined;
  enabled: boolean;
  environments: Array<string>;
  connections?: Array<UpdateFlagSettingsFeatureFlagsConnections> | undefined;
  entities: Array<UpdateFlagSettingsFeatureFlagsResponseEntities>;
  createdAt?: number | undefined;
  updatedAt?: number | undefined;
  metadata: UpdateFlagSettingsFeatureFlagsMetadata;
};

export const UpdateFlagSettingsTypeName = {
  Settings: "settings",
} as const;
export type UpdateFlagSettingsTypeName = ClosedEnum<
  typeof UpdateFlagSettingsTypeName
>;

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

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

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

export type UpdateFlagSettingsFeatureFlagsEntities = {
  kind: string;
  label: string;
  attributes: Array<UpdateFlagSettingsAttributes>;
};

export type UpdateFlagSettingsMetadata = {
  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 UpdateFlagSettingsResponseBody = {
  typeName: UpdateFlagSettingsTypeName;
  projectId: string;
  ownerId?: string | undefined;
  enabled: boolean;
  environments: Array<string>;
  connections?: Array<UpdateFlagSettingsConnections> | undefined;
  entities: Array<UpdateFlagSettingsFeatureFlagsEntities>;
  createdAt?: number | undefined;
  updatedAt?: number | undefined;
  metadata: UpdateFlagSettingsMetadata;
};

export type UpdateFlagSettingsResponse =
  | UpdateFlagSettingsResponseBody
  | UpdateFlagSettingsFeatureFlagsResponseBody;

/** @internal */
export type Labels$Outbound = {
  label: string;
  value: string;
};

/** @internal */
export const Labels$outboundSchema: z.ZodType<
  Labels$Outbound,
  z.ZodTypeDef,
  Labels
> = z.object({
  label: z.string(),
  value: z.string(),
});

export function labelsToJSON(labels: Labels): string {
  return JSON.stringify(Labels$outboundSchema.parse(labels));
}

/** @internal */
export type Attributes$Outbound = {
  key: string;
  type: string;
  labels?: Array<Labels$Outbound> | undefined;
};

/** @internal */
export const Attributes$outboundSchema: z.ZodType<
  Attributes$Outbound,
  z.ZodTypeDef,
  Attributes
> = z.object({
  key: z.string(),
  type: z.string(),
  labels: z.array(z.lazy(() => Labels$outboundSchema)).optional(),
});

export function attributesToJSON(attributes: Attributes): string {
  return JSON.stringify(Attributes$outboundSchema.parse(attributes));
}

/** @internal */
export type UpdateFlagSettingsEntities$Outbound = {
  kind: string;
  label: string;
  attributes: Array<Attributes$Outbound>;
};

/** @internal */
export const UpdateFlagSettingsEntities$outboundSchema: z.ZodType<
  UpdateFlagSettingsEntities$Outbound,
  z.ZodTypeDef,
  UpdateFlagSettingsEntities
> = z.object({
  kind: z.string(),
  label: z.string(),
  attributes: z.array(z.lazy(() => Attributes$outboundSchema)),
});

export function updateFlagSettingsEntitiesToJSON(
  updateFlagSettingsEntities: UpdateFlagSettingsEntities,
): string {
  return JSON.stringify(
    UpdateFlagSettingsEntities$outboundSchema.parse(updateFlagSettingsEntities),
  );
}

/** @internal */
export type UpdateFlagSettingsRequestBody$Outbound = {
  enabled?: boolean | undefined;
  entities?: Array<UpdateFlagSettingsEntities$Outbound> | undefined;
  environments?: Array<string> | undefined;
};

/** @internal */
export const UpdateFlagSettingsRequestBody$outboundSchema: z.ZodType<
  UpdateFlagSettingsRequestBody$Outbound,
  z.ZodTypeDef,
  UpdateFlagSettingsRequestBody
> = z.object({
  enabled: z.boolean().optional(),
  entities: z.array(z.lazy(() => UpdateFlagSettingsEntities$outboundSchema))
    .optional(),
  environments: z.array(z.string()).optional(),
});

export function updateFlagSettingsRequestBodyToJSON(
  updateFlagSettingsRequestBody: UpdateFlagSettingsRequestBody,
): string {
  return JSON.stringify(
    UpdateFlagSettingsRequestBody$outboundSchema.parse(
      updateFlagSettingsRequestBody,
    ),
  );
}

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

/** @internal */
export const UpdateFlagSettingsRequest$outboundSchema: z.ZodType<
  UpdateFlagSettingsRequest$Outbound,
  z.ZodTypeDef,
  UpdateFlagSettingsRequest
> = z.object({
  projectIdOrName: z.string(),
  teamId: z.string().optional(),
  slug: z.string().optional(),
  requestBody: z.lazy(() => UpdateFlagSettingsRequestBody$outboundSchema)
    .optional(),
}).transform((v) => {
  return remap$(v, {
    requestBody: "RequestBody",
  });
});

export function updateFlagSettingsRequestToJSON(
  updateFlagSettingsRequest: UpdateFlagSettingsRequest,
): string {
  return JSON.stringify(
    UpdateFlagSettingsRequest$outboundSchema.parse(updateFlagSettingsRequest),
  );
}

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

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

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

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

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

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

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

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

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

/** @internal */
export const UpdateFlagSettingsFeatureFlagsMetadata$inboundSchema: z.ZodType<
  UpdateFlagSettingsFeatureFlagsMetadata,
  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 updateFlagSettingsFeatureFlagsMetadataFromJSON(
  jsonString: string,
): SafeParseResult<UpdateFlagSettingsFeatureFlagsMetadata, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      UpdateFlagSettingsFeatureFlagsMetadata$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateFlagSettingsFeatureFlagsMetadata' from JSON`,
  );
}

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

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

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

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

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

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

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

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

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

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

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

/** @internal */
export const UpdateFlagSettingsMetadata$inboundSchema: z.ZodType<
  UpdateFlagSettingsMetadata,
  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 updateFlagSettingsMetadataFromJSON(
  jsonString: string,
): SafeParseResult<UpdateFlagSettingsMetadata, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => UpdateFlagSettingsMetadata$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'UpdateFlagSettingsMetadata' from JSON`,
  );
}

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

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

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

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