@meetkai/mka1 0.54.48 → 0.54.49

package/src/models/operations/archivefeatureflag.ts

@@ -0,0 +1,67 @@
+/*
+ * 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 { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type ArchiveFeatureFlagRequest = {
+  key: string;
+  /**
+   * Optional external end-user identifier forwarded by the API gateway.
+   */
+  xOnBehalfOf?: string | undefined;
+};
+
+/** @internal */
+export const ArchiveFeatureFlagRequest$inboundSchema: z.ZodType<
+  ArchiveFeatureFlagRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  key: z.string(),
+  "X-On-Behalf-Of": z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "X-On-Behalf-Of": "xOnBehalfOf",
+  });
+});
+/** @internal */
+export type ArchiveFeatureFlagRequest$Outbound = {
+  key: string;
+  "X-On-Behalf-Of"?: string | undefined;
+};
+
+/** @internal */
+export const ArchiveFeatureFlagRequest$outboundSchema: z.ZodType<
+  ArchiveFeatureFlagRequest$Outbound,
+  z.ZodTypeDef,
+  ArchiveFeatureFlagRequest
+> = z.object({
+  key: z.string(),
+  xOnBehalfOf: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    xOnBehalfOf: "X-On-Behalf-Of",
+  });
+});
+
+export function archiveFeatureFlagRequestToJSON(
+  archiveFeatureFlagRequest: ArchiveFeatureFlagRequest,
+): string {
+  return JSON.stringify(
+    ArchiveFeatureFlagRequest$outboundSchema.parse(archiveFeatureFlagRequest),
+  );
+}
+export function archiveFeatureFlagRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<ArchiveFeatureFlagRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ArchiveFeatureFlagRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ArchiveFeatureFlagRequest' from JSON`,
+  );
+}

package/src/models/operations/createfeatureflag.ts

@@ -0,0 +1,70 @@
+/*
+ * 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 { Result as SafeParseResult } from "../../types/fp.js";
+import * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type CreateFeatureFlagRequest = {
+  /**
+   * Optional external end-user identifier forwarded by the API gateway.
+   */
+  xOnBehalfOf?: string | undefined;
+  featureFlagCreateRequest: components.FeatureFlagCreateRequest;
+};
+
+/** @internal */
+export const CreateFeatureFlagRequest$inboundSchema: z.ZodType<
+  CreateFeatureFlagRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  "X-On-Behalf-Of": z.string().optional(),
+  FeatureFlagCreateRequest: components.FeatureFlagCreateRequest$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "X-On-Behalf-Of": "xOnBehalfOf",
+    "FeatureFlagCreateRequest": "featureFlagCreateRequest",
+  });
+});
+/** @internal */
+export type CreateFeatureFlagRequest$Outbound = {
+  "X-On-Behalf-Of"?: string | undefined;
+  FeatureFlagCreateRequest: components.FeatureFlagCreateRequest$Outbound;
+};
+
+/** @internal */
+export const CreateFeatureFlagRequest$outboundSchema: z.ZodType<
+  CreateFeatureFlagRequest$Outbound,
+  z.ZodTypeDef,
+  CreateFeatureFlagRequest
+> = z.object({
+  xOnBehalfOf: z.string().optional(),
+  featureFlagCreateRequest: components.FeatureFlagCreateRequest$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    xOnBehalfOf: "X-On-Behalf-Of",
+    featureFlagCreateRequest: "FeatureFlagCreateRequest",
+  });
+});
+
+export function createFeatureFlagRequestToJSON(
+  createFeatureFlagRequest: CreateFeatureFlagRequest,
+): string {
+  return JSON.stringify(
+    CreateFeatureFlagRequest$outboundSchema.parse(createFeatureFlagRequest),
+  );
+}
+export function createFeatureFlagRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateFeatureFlagRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateFeatureFlagRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateFeatureFlagRequest' from JSON`,
+  );
+}

package/src/models/operations/createfeatureflagenvironment.ts

@@ -0,0 +1,78 @@
+/*
+ * 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 { Result as SafeParseResult } from "../../types/fp.js";
+import * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type CreateFeatureFlagEnvironmentRequest = {
+  /**
+   * Optional external end-user identifier forwarded by the API gateway.
+   */
+  xOnBehalfOf?: string | undefined;
+  featureFlagEnvironmentCreateRequest:
+    components.FeatureFlagEnvironmentCreateRequest;
+};
+
+/** @internal */
+export const CreateFeatureFlagEnvironmentRequest$inboundSchema: z.ZodType<
+  CreateFeatureFlagEnvironmentRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  "X-On-Behalf-Of": z.string().optional(),
+  FeatureFlagEnvironmentCreateRequest:
+    components.FeatureFlagEnvironmentCreateRequest$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "X-On-Behalf-Of": "xOnBehalfOf",
+    "FeatureFlagEnvironmentCreateRequest":
+      "featureFlagEnvironmentCreateRequest",
+  });
+});
+/** @internal */
+export type CreateFeatureFlagEnvironmentRequest$Outbound = {
+  "X-On-Behalf-Of"?: string | undefined;
+  FeatureFlagEnvironmentCreateRequest:
+    components.FeatureFlagEnvironmentCreateRequest$Outbound;
+};
+
+/** @internal */
+export const CreateFeatureFlagEnvironmentRequest$outboundSchema: z.ZodType<
+  CreateFeatureFlagEnvironmentRequest$Outbound,
+  z.ZodTypeDef,
+  CreateFeatureFlagEnvironmentRequest
+> = z.object({
+  xOnBehalfOf: z.string().optional(),
+  featureFlagEnvironmentCreateRequest:
+    components.FeatureFlagEnvironmentCreateRequest$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    xOnBehalfOf: "X-On-Behalf-Of",
+    featureFlagEnvironmentCreateRequest: "FeatureFlagEnvironmentCreateRequest",
+  });
+});
+
+export function createFeatureFlagEnvironmentRequestToJSON(
+  createFeatureFlagEnvironmentRequest: CreateFeatureFlagEnvironmentRequest,
+): string {
+  return JSON.stringify(
+    CreateFeatureFlagEnvironmentRequest$outboundSchema.parse(
+      createFeatureFlagEnvironmentRequest,
+    ),
+  );
+}
+export function createFeatureFlagEnvironmentRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateFeatureFlagEnvironmentRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateFeatureFlagEnvironmentRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateFeatureFlagEnvironmentRequest' from JSON`,
+  );
+}

package/src/models/operations/deletefeatureflag.ts

@@ -0,0 +1,67 @@
+/*
+ * 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 { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type DeleteFeatureFlagRequest = {
+  key: string;
+  /**
+   * Optional external end-user identifier forwarded by the API gateway.
+   */
+  xOnBehalfOf?: string | undefined;
+};
+
+/** @internal */
+export const DeleteFeatureFlagRequest$inboundSchema: z.ZodType<
+  DeleteFeatureFlagRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  key: z.string(),
+  "X-On-Behalf-Of": z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "X-On-Behalf-Of": "xOnBehalfOf",
+  });
+});
+/** @internal */
+export type DeleteFeatureFlagRequest$Outbound = {
+  key: string;
+  "X-On-Behalf-Of"?: string | undefined;
+};
+
+/** @internal */
+export const DeleteFeatureFlagRequest$outboundSchema: z.ZodType<
+  DeleteFeatureFlagRequest$Outbound,
+  z.ZodTypeDef,
+  DeleteFeatureFlagRequest
+> = z.object({
+  key: z.string(),
+  xOnBehalfOf: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    xOnBehalfOf: "X-On-Behalf-Of",
+  });
+});
+
+export function deleteFeatureFlagRequestToJSON(
+  deleteFeatureFlagRequest: DeleteFeatureFlagRequest,
+): string {
+  return JSON.stringify(
+    DeleteFeatureFlagRequest$outboundSchema.parse(deleteFeatureFlagRequest),
+  );
+}
+export function deleteFeatureFlagRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<DeleteFeatureFlagRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeleteFeatureFlagRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeleteFeatureFlagRequest' from JSON`,
+  );
+}

package/src/models/operations/deletefeatureflagenvironment.ts

@@ -0,0 +1,70 @@
+/*
+ * 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 { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type DeleteFeatureFlagEnvironmentRequest = {
+  env: string;
+  /**
+   * Optional external end-user identifier forwarded by the API gateway.
+   */
+  xOnBehalfOf?: string | undefined;
+};
+
+/** @internal */
+export const DeleteFeatureFlagEnvironmentRequest$inboundSchema: z.ZodType<
+  DeleteFeatureFlagEnvironmentRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  env: z.string(),
+  "X-On-Behalf-Of": z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "X-On-Behalf-Of": "xOnBehalfOf",
+  });
+});
+/** @internal */
+export type DeleteFeatureFlagEnvironmentRequest$Outbound = {
+  env: string;
+  "X-On-Behalf-Of"?: string | undefined;
+};
+
+/** @internal */
+export const DeleteFeatureFlagEnvironmentRequest$outboundSchema: z.ZodType<
+  DeleteFeatureFlagEnvironmentRequest$Outbound,
+  z.ZodTypeDef,
+  DeleteFeatureFlagEnvironmentRequest
+> = z.object({
+  env: z.string(),
+  xOnBehalfOf: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    xOnBehalfOf: "X-On-Behalf-Of",
+  });
+});
+
+export function deleteFeatureFlagEnvironmentRequestToJSON(
+  deleteFeatureFlagEnvironmentRequest: DeleteFeatureFlagEnvironmentRequest,
+): string {
+  return JSON.stringify(
+    DeleteFeatureFlagEnvironmentRequest$outboundSchema.parse(
+      deleteFeatureFlagEnvironmentRequest,
+    ),
+  );
+}
+export function deleteFeatureFlagEnvironmentRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<DeleteFeatureFlagEnvironmentRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DeleteFeatureFlagEnvironmentRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeleteFeatureFlagEnvironmentRequest' from JSON`,
+  );
+}

package/src/models/operations/evaluatefeatureflags.ts

@@ -0,0 +1,181 @@
+/*
+ * 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 { Result as SafeParseResult } from "../../types/fp.js";
+import * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type EvaluateFeatureFlagsSecurity = {
+  evaluationKeyAuth: string;
+};
+
+export type EvaluateFeatureFlagsRequest = {
+  env: string;
+  /**
+   * Stable identifier of the caller; enables rollouts and overrides.
+   */
+  identity?: string | undefined;
+  /**
+   * Optional external end-user identifier forwarded by the API gateway.
+   */
+  xOnBehalfOf?: string | undefined;
+};
+
+export type EvaluateFeatureFlagsResponse = {
+  headers: { [k: string]: Array<string> };
+  result?: components.FeatureFlagEvaluateResponse | undefined;
+};
+
+/** @internal */
+export const EvaluateFeatureFlagsSecurity$inboundSchema: z.ZodType<
+  EvaluateFeatureFlagsSecurity,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  evaluationKeyAuth: z.string(),
+});
+/** @internal */
+export type EvaluateFeatureFlagsSecurity$Outbound = {
+  evaluationKeyAuth: string;
+};
+
+/** @internal */
+export const EvaluateFeatureFlagsSecurity$outboundSchema: z.ZodType<
+  EvaluateFeatureFlagsSecurity$Outbound,
+  z.ZodTypeDef,
+  EvaluateFeatureFlagsSecurity
+> = z.object({
+  evaluationKeyAuth: z.string(),
+});
+
+export function evaluateFeatureFlagsSecurityToJSON(
+  evaluateFeatureFlagsSecurity: EvaluateFeatureFlagsSecurity,
+): string {
+  return JSON.stringify(
+    EvaluateFeatureFlagsSecurity$outboundSchema.parse(
+      evaluateFeatureFlagsSecurity,
+    ),
+  );
+}
+export function evaluateFeatureFlagsSecurityFromJSON(
+  jsonString: string,
+): SafeParseResult<EvaluateFeatureFlagsSecurity, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EvaluateFeatureFlagsSecurity$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EvaluateFeatureFlagsSecurity' from JSON`,
+  );
+}
+
+/** @internal */
+export const EvaluateFeatureFlagsRequest$inboundSchema: z.ZodType<
+  EvaluateFeatureFlagsRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  env: z.string(),
+  identity: z.string().optional(),
+  "X-On-Behalf-Of": z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "X-On-Behalf-Of": "xOnBehalfOf",
+  });
+});
+/** @internal */
+export type EvaluateFeatureFlagsRequest$Outbound = {
+  env: string;
+  identity?: string | undefined;
+  "X-On-Behalf-Of"?: string | undefined;
+};
+
+/** @internal */
+export const EvaluateFeatureFlagsRequest$outboundSchema: z.ZodType<
+  EvaluateFeatureFlagsRequest$Outbound,
+  z.ZodTypeDef,
+  EvaluateFeatureFlagsRequest
+> = z.object({
+  env: z.string(),
+  identity: z.string().optional(),
+  xOnBehalfOf: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    xOnBehalfOf: "X-On-Behalf-Of",
+  });
+});
+
+export function evaluateFeatureFlagsRequestToJSON(
+  evaluateFeatureFlagsRequest: EvaluateFeatureFlagsRequest,
+): string {
+  return JSON.stringify(
+    EvaluateFeatureFlagsRequest$outboundSchema.parse(
+      evaluateFeatureFlagsRequest,
+    ),
+  );
+}
+export function evaluateFeatureFlagsRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<EvaluateFeatureFlagsRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EvaluateFeatureFlagsRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EvaluateFeatureFlagsRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const EvaluateFeatureFlagsResponse$inboundSchema: z.ZodType<
+  EvaluateFeatureFlagsResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  Headers: z.record(z.array(z.string())).default({}),
+  Result: components.FeatureFlagEvaluateResponse$inboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "Headers": "headers",
+    "Result": "result",
+  });
+});
+/** @internal */
+export type EvaluateFeatureFlagsResponse$Outbound = {
+  Headers: { [k: string]: Array<string> };
+  Result?: components.FeatureFlagEvaluateResponse$Outbound | undefined;
+};
+
+/** @internal */
+export const EvaluateFeatureFlagsResponse$outboundSchema: z.ZodType<
+  EvaluateFeatureFlagsResponse$Outbound,
+  z.ZodTypeDef,
+  EvaluateFeatureFlagsResponse
+> = z.object({
+  headers: z.record(z.array(z.string())),
+  result: components.FeatureFlagEvaluateResponse$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    headers: "Headers",
+    result: "Result",
+  });
+});
+
+export function evaluateFeatureFlagsResponseToJSON(
+  evaluateFeatureFlagsResponse: EvaluateFeatureFlagsResponse,
+): string {
+  return JSON.stringify(
+    EvaluateFeatureFlagsResponse$outboundSchema.parse(
+      evaluateFeatureFlagsResponse,
+    ),
+  );
+}
+export function evaluateFeatureFlagsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<EvaluateFeatureFlagsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EvaluateFeatureFlagsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EvaluateFeatureFlagsResponse' from JSON`,
+  );
+}

package/src/models/operations/evaluatefeatureflagswithtraits.ts

@@ -0,0 +1,126 @@
+/*
+ * 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 { Result as SafeParseResult } from "../../types/fp.js";
+import * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type EvaluateFeatureFlagsWithTraitsSecurity = {
+  evaluationKeyAuth: string;
+};
+
+export type EvaluateFeatureFlagsWithTraitsRequest = {
+  env: string;
+  /**
+   * Optional external end-user identifier forwarded by the API gateway.
+   */
+  xOnBehalfOf?: string | undefined;
+  featureFlagEvaluateRequest: components.FeatureFlagEvaluateRequest;
+};
+
+/** @internal */
+export const EvaluateFeatureFlagsWithTraitsSecurity$inboundSchema: z.ZodType<
+  EvaluateFeatureFlagsWithTraitsSecurity,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  evaluationKeyAuth: z.string(),
+});
+/** @internal */
+export type EvaluateFeatureFlagsWithTraitsSecurity$Outbound = {
+  evaluationKeyAuth: string;
+};
+
+/** @internal */
+export const EvaluateFeatureFlagsWithTraitsSecurity$outboundSchema: z.ZodType<
+  EvaluateFeatureFlagsWithTraitsSecurity$Outbound,
+  z.ZodTypeDef,
+  EvaluateFeatureFlagsWithTraitsSecurity
+> = z.object({
+  evaluationKeyAuth: z.string(),
+});
+
+export function evaluateFeatureFlagsWithTraitsSecurityToJSON(
+  evaluateFeatureFlagsWithTraitsSecurity:
+    EvaluateFeatureFlagsWithTraitsSecurity,
+): string {
+  return JSON.stringify(
+    EvaluateFeatureFlagsWithTraitsSecurity$outboundSchema.parse(
+      evaluateFeatureFlagsWithTraitsSecurity,
+    ),
+  );
+}
+export function evaluateFeatureFlagsWithTraitsSecurityFromJSON(
+  jsonString: string,
+): SafeParseResult<EvaluateFeatureFlagsWithTraitsSecurity, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      EvaluateFeatureFlagsWithTraitsSecurity$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EvaluateFeatureFlagsWithTraitsSecurity' from JSON`,
+  );
+}
+
+/** @internal */
+export const EvaluateFeatureFlagsWithTraitsRequest$inboundSchema: z.ZodType<
+  EvaluateFeatureFlagsWithTraitsRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  env: z.string(),
+  "X-On-Behalf-Of": z.string().optional(),
+  FeatureFlagEvaluateRequest:
+    components.FeatureFlagEvaluateRequest$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "X-On-Behalf-Of": "xOnBehalfOf",
+    "FeatureFlagEvaluateRequest": "featureFlagEvaluateRequest",
+  });
+});
+/** @internal */
+export type EvaluateFeatureFlagsWithTraitsRequest$Outbound = {
+  env: string;
+  "X-On-Behalf-Of"?: string | undefined;
+  FeatureFlagEvaluateRequest: components.FeatureFlagEvaluateRequest$Outbound;
+};
+
+/** @internal */
+export const EvaluateFeatureFlagsWithTraitsRequest$outboundSchema: z.ZodType<
+  EvaluateFeatureFlagsWithTraitsRequest$Outbound,
+  z.ZodTypeDef,
+  EvaluateFeatureFlagsWithTraitsRequest
+> = z.object({
+  env: z.string(),
+  xOnBehalfOf: z.string().optional(),
+  featureFlagEvaluateRequest:
+    components.FeatureFlagEvaluateRequest$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    xOnBehalfOf: "X-On-Behalf-Of",
+    featureFlagEvaluateRequest: "FeatureFlagEvaluateRequest",
+  });
+});
+
+export function evaluateFeatureFlagsWithTraitsRequestToJSON(
+  evaluateFeatureFlagsWithTraitsRequest: EvaluateFeatureFlagsWithTraitsRequest,
+): string {
+  return JSON.stringify(
+    EvaluateFeatureFlagsWithTraitsRequest$outboundSchema.parse(
+      evaluateFeatureFlagsWithTraitsRequest,
+    ),
+  );
+}
+export function evaluateFeatureFlagsWithTraitsRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<EvaluateFeatureFlagsWithTraitsRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      EvaluateFeatureFlagsWithTraitsRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EvaluateFeatureFlagsWithTraitsRequest' from JSON`,
+  );
+}