@vercel/sdk/esm/models/createflagsegmentop.js

<p align="center"> <a href="https://vercel.com"> <img src="https://assets.vercel.com/image/upload/v1588805858/repositories/vercel/logo.png" height="96"> <h3 align="center">Vercel</h3> </a> <p align="center">Develop. Preview. Ship.</p> </p>

/*
 * 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 * as types from "../types/primitives.js";
import { smartUnion } from "../types/smartUnion.js";
export const CreateFlagSegmentCmp = {
    Eq: "eq",
    NotEq: "!eq",
    OneOf: "oneOf",
    NotOneOf: "!oneOf",
    ContainsAllOf: "containsAllOf",
    ContainsAnyOf: "containsAnyOf",
    ContainsNoneOf: "containsNoneOf",
    StartsWith: "startsWith",
    NotStartsWith: "!startsWith",
    EndsWith: "endsWith",
    NotEndsWith: "!endsWith",
    Contains: "contains",
    NotContains: "!contains",
    Ex: "ex",
    NotEx: "!ex",
    Gt: "gt",
    Gte: "gte",
    Lt: "lt",
    Lte: "lte",
    Regex: "regex",
    NotRegex: "!regex",
    Before: "before",
    After: "after",
};
export const CreateFlagSegmentRhsType = {
    ListInline: "list/inline",
    List: "list",
};
export const CreateFlagSegmentOutcomeFeatureFlagsResponseType = {
    Entity: "entity",
};
export const CreateFlagSegmentRhsFeatureFlagsResponseType = {
    Regex: "regex",
};
export const CreateFlagSegmentRhsFeatureFlagsType = {
    List: "list",
    ListInline: "list/inline",
};
export const CreateFlagSegmentFeatureFlagsCmp = {
    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",
};
export const CreateFlagSegmentTypeName = {
    Segment: "segment",
};
/** @internal */
export const CreateFlagSegmentLhs2$outboundSchema = z.object({
    type: z.any().optional(),
    kind: z.string(),
    attribute: z.string(),
});
export function createFlagSegmentLhs2ToJSON(createFlagSegmentLhs2) {
    return JSON.stringify(CreateFlagSegmentLhs2$outboundSchema.parse(createFlagSegmentLhs2));
}
/** @internal */
export const CreateFlagSegmentLhs1$outboundSchema = z.object({
    type: z.any().optional(),
});
export function createFlagSegmentLhs1ToJSON(createFlagSegmentLhs1) {
    return JSON.stringify(CreateFlagSegmentLhs1$outboundSchema.parse(createFlagSegmentLhs1));
}
/** @internal */
export const CreateFlagSegmentLhs$outboundSchema = smartUnion([
    z.lazy(() => CreateFlagSegmentLhs2$outboundSchema),
    z.lazy(() => CreateFlagSegmentLhs1$outboundSchema),
]);
export function createFlagSegmentLhsToJSON(createFlagSegmentLhs) {
    return JSON.stringify(CreateFlagSegmentLhs$outboundSchema.parse(createFlagSegmentLhs));
}
/** @internal */
export const CreateFlagSegmentCmp$outboundSchema = z.nativeEnum(CreateFlagSegmentCmp);
/** @internal */
export const CreateFlagSegmentRhs2$outboundSchema = z.object({
    type: z.any().optional(),
    pattern: z.string(),
    flags: z.string(),
});
export function createFlagSegmentRhs2ToJSON(createFlagSegmentRhs2) {
    return JSON.stringify(CreateFlagSegmentRhs2$outboundSchema.parse(createFlagSegmentRhs2));
}
/** @internal */
export const CreateFlagSegmentRhsType$outboundSchema = z.nativeEnum(CreateFlagSegmentRhsType);
/** @internal */
export const CreateFlagSegmentItems2$outboundSchema = z.object({
    label: z.string().optional(),
    note: z.string().optional(),
    value: z.string(),
});
export function createFlagSegmentItems2ToJSON(createFlagSegmentItems2) {
    return JSON.stringify(CreateFlagSegmentItems2$outboundSchema.parse(createFlagSegmentItems2));
}
/** @internal */
export const CreateFlagSegmentItems1$outboundSchema = z.object({
    label: z.string().optional(),
    note: z.string().optional(),
    value: z.number(),
});
export function createFlagSegmentItems1ToJSON(createFlagSegmentItems1) {
    return JSON.stringify(CreateFlagSegmentItems1$outboundSchema.parse(createFlagSegmentItems1));
}
/** @internal */
export const CreateFlagSegmentRhsItems$outboundSchema = smartUnion([
    z.lazy(() => CreateFlagSegmentItems1$outboundSchema),
    z.lazy(() => CreateFlagSegmentItems2$outboundSchema),
]);
export function createFlagSegmentRhsItemsToJSON(createFlagSegmentRhsItems) {
    return JSON.stringify(CreateFlagSegmentRhsItems$outboundSchema.parse(createFlagSegmentRhsItems));
}
/** @internal */
export const CreateFlagSegmentRhs1$outboundSchema = z.object({
    type: CreateFlagSegmentRhsType$outboundSchema,
    items: z.array(smartUnion([
        z.lazy(() => CreateFlagSegmentItems1$outboundSchema),
        z.lazy(() => CreateFlagSegmentItems2$outboundSchema),
    ])),
});
export function createFlagSegmentRhs1ToJSON(createFlagSegmentRhs1) {
    return JSON.stringify(CreateFlagSegmentRhs1$outboundSchema.parse(createFlagSegmentRhs1));
}
/** @internal */
export const CreateFlagSegmentRhs$outboundSchema = smartUnion([
    z.lazy(() => CreateFlagSegmentRhs2$outboundSchema),
    z.lazy(() => CreateFlagSegmentRhs1$outboundSchema),
    z.string(),
    z.number(),
    z.boolean(),
]);
export function createFlagSegmentRhsToJSON(createFlagSegmentRhs) {
    return JSON.stringify(CreateFlagSegmentRhs$outboundSchema.parse(createFlagSegmentRhs));
}
/** @internal */
export const CreateFlagSegmentCmpOptions$outboundSchema = z.object({
    ignoreCase: z.boolean().optional(),
});
export function createFlagSegmentCmpOptionsToJSON(createFlagSegmentCmpOptions) {
    return JSON.stringify(CreateFlagSegmentCmpOptions$outboundSchema.parse(createFlagSegmentCmpOptions));
}
/** @internal */
export const CreateFlagSegmentConditions$outboundSchema = z.object({
    lhs: smartUnion([
        z.lazy(() => CreateFlagSegmentLhs2$outboundSchema),
        z.lazy(() => CreateFlagSegmentLhs1$outboundSchema),
    ]),
    cmp: CreateFlagSegmentCmp$outboundSchema,
    rhs: smartUnion([
        z.lazy(() => CreateFlagSegmentRhs2$outboundSchema),
        z.lazy(() => CreateFlagSegmentRhs1$outboundSchema),
        z.string(),
        z.number(),
        z.boolean(),
    ]).optional(),
    cmpOptions: z.lazy(() => CreateFlagSegmentCmpOptions$outboundSchema)
        .optional(),
});
export function createFlagSegmentConditionsToJSON(createFlagSegmentConditions) {
    return JSON.stringify(CreateFlagSegmentConditions$outboundSchema.parse(createFlagSegmentConditions));
}
/** @internal */
export const CreateFlagSegmentOutcomeBase$outboundSchema = z.object({
    type: z.any().optional(),
    kind: z.string(),
    attribute: z.string(),
});
export function createFlagSegmentOutcomeBaseToJSON(createFlagSegmentOutcomeBase) {
    return JSON.stringify(CreateFlagSegmentOutcomeBase$outboundSchema.parse(createFlagSegmentOutcomeBase));
}
/** @internal */
export const CreateFlagSegmentOutcome2$outboundSchema = z.object({
    type: z.any().optional(),
    base: z.lazy(() => CreateFlagSegmentOutcomeBase$outboundSchema),
    passPromille: z.number(),
});
export function createFlagSegmentOutcome2ToJSON(createFlagSegmentOutcome2) {
    return JSON.stringify(CreateFlagSegmentOutcome2$outboundSchema.parse(createFlagSegmentOutcome2));
}
/** @internal */
export const CreateFlagSegmentOutcome1$outboundSchema = z.object({
    type: z.any().optional(),
});
export function createFlagSegmentOutcome1ToJSON(createFlagSegmentOutcome1) {
    return JSON.stringify(CreateFlagSegmentOutcome1$outboundSchema.parse(createFlagSegmentOutcome1));
}
/** @internal */
export const CreateFlagSegmentOutcome$outboundSchema = smartUnion([
    z.lazy(() => CreateFlagSegmentOutcome2$outboundSchema),
    z.lazy(() => CreateFlagSegmentOutcome1$outboundSchema),
]);
export function createFlagSegmentOutcomeToJSON(createFlagSegmentOutcome) {
    return JSON.stringify(CreateFlagSegmentOutcome$outboundSchema.parse(createFlagSegmentOutcome));
}
/** @internal */
export const CreateFlagSegmentRules$outboundSchema = z.object({
    id: z.string(),
    conditions: z.array(z.lazy(() => CreateFlagSegmentConditions$outboundSchema)),
    outcome: smartUnion([
        z.lazy(() => CreateFlagSegmentOutcome2$outboundSchema),
        z.lazy(() => CreateFlagSegmentOutcome1$outboundSchema),
    ]),
});
export function createFlagSegmentRulesToJSON(createFlagSegmentRules) {
    return JSON.stringify(CreateFlagSegmentRules$outboundSchema.parse(createFlagSegmentRules));
}
/** @internal */
export const CreateFlagSegmentInclude$outboundSchema = z.object({
    note: z.string().optional(),
    value: z.string(),
});
export function createFlagSegmentIncludeToJSON(createFlagSegmentInclude) {
    return JSON.stringify(CreateFlagSegmentInclude$outboundSchema.parse(createFlagSegmentInclude));
}
/** @internal */
export const CreateFlagSegmentExclude$outboundSchema = z.object({
    note: z.string().optional(),
    value: z.string(),
});
export function createFlagSegmentExcludeToJSON(createFlagSegmentExclude) {
    return JSON.stringify(CreateFlagSegmentExclude$outboundSchema.parse(createFlagSegmentExclude));
}
/** @internal */
export const CreateFlagSegmentData$outboundSchema = z.object({
    rules: z.array(z.lazy(() => CreateFlagSegmentRules$outboundSchema))
        .optional(),
    include: z.record(z.record(z.array(z.lazy(() => CreateFlagSegmentInclude$outboundSchema)))).optional(),
    exclude: z.record(z.record(z.array(z.lazy(() => CreateFlagSegmentExclude$outboundSchema)))).optional(),
});
export function createFlagSegmentDataToJSON(createFlagSegmentData) {
    return JSON.stringify(CreateFlagSegmentData$outboundSchema.parse(createFlagSegmentData));
}
/** @internal */
export const CreateFlagSegmentRequestBody$outboundSchema = z.object({
    slug: z.string(),
    createdBy: z.string().optional(),
    label: z.string(),
    description: z.string().optional(),
    data: z.lazy(() => CreateFlagSegmentData$outboundSchema),
    hint: z.string(),
});
export function createFlagSegmentRequestBodyToJSON(createFlagSegmentRequestBody) {
    return JSON.stringify(CreateFlagSegmentRequestBody$outboundSchema.parse(createFlagSegmentRequestBody));
}
/** @internal */
export const CreateFlagSegmentRequest$outboundSchema = z.object({
    projectIdOrName: z.string(),
    teamId: z.string().optional(),
    slug: z.string().optional(),
    requestBody: z.lazy(() => CreateFlagSegmentRequestBody$outboundSchema)
        .optional(),
}).transform((v) => {
    return remap$(v, {
        requestBody: "RequestBody",
    });
});
export function createFlagSegmentRequestToJSON(createFlagSegmentRequest) {
    return JSON.stringify(CreateFlagSegmentRequest$outboundSchema.parse(createFlagSegmentRequest));
}
/** @internal */
export const CreateFlagSegmentOutcomeFeatureFlagsResponseType$inboundSchema = z
    .nativeEnum(CreateFlagSegmentOutcomeFeatureFlagsResponseType);
/** @internal */
export const CreateFlagSegmentOutcomeFeatureFlagsBase$inboundSchema = z.object({
    type: CreateFlagSegmentOutcomeFeatureFlagsResponseType$inboundSchema,
    kind: types.string(),
    attribute: types.string(),
});
export function createFlagSegmentOutcomeFeatureFlagsBaseFromJSON(jsonString) {
    return safeParse(jsonString, (x) => CreateFlagSegmentOutcomeFeatureFlagsBase$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateFlagSegmentOutcomeFeatureFlagsBase' from JSON`);
}
/** @internal */
export const CreateFlagSegmentOutcomeFeatureFlags2$inboundSchema = z.object({
    type: types.literal("split"),
    base: z.lazy(() => CreateFlagSegmentOutcomeFeatureFlagsBase$inboundSchema),
    passPromille: types.number(),
});
export function createFlagSegmentOutcomeFeatureFlags2FromJSON(jsonString) {
    return safeParse(jsonString, (x) => CreateFlagSegmentOutcomeFeatureFlags2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateFlagSegmentOutcomeFeatureFlags2' from JSON`);
}
/** @internal */
export const CreateFlagSegmentOutcomeFeatureFlags1$inboundSchema = z.object({
    type: types.literal("all"),
});
export function createFlagSegmentOutcomeFeatureFlags1FromJSON(jsonString) {
    return safeParse(jsonString, (x) => CreateFlagSegmentOutcomeFeatureFlags1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateFlagSegmentOutcomeFeatureFlags1' from JSON`);
}
/** @internal */
export const CreateFlagSegmentFeatureFlagsOutcome$inboundSchema = z.union([
    z.lazy(() => CreateFlagSegmentOutcomeFeatureFlags1$inboundSchema),
    z.lazy(() => CreateFlagSegmentOutcomeFeatureFlags2$inboundSchema),
]);
export function createFlagSegmentFeatureFlagsOutcomeFromJSON(jsonString) {
    return safeParse(jsonString, (x) => CreateFlagSegmentFeatureFlagsOutcome$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateFlagSegmentFeatureFlagsOutcome' from JSON`);
}
/** @internal */
export const CreateFlagSegmentRhsFeatureFlagsResponseType$inboundSchema = z
    .nativeEnum(CreateFlagSegmentRhsFeatureFlagsResponseType);
/** @internal */
export const CreateFlagSegmentRhs4$inboundSchema = z.object({
    type: CreateFlagSegmentRhsFeatureFlagsResponseType$inboundSchema,
    pattern: types.string(),
    flags: types.string(),
});
export function createFlagSegmentRhs4FromJSON(jsonString) {
    return safeParse(jsonString, (x) => CreateFlagSegmentRhs4$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateFlagSegmentRhs4' from JSON`);
}
/** @internal */
export const CreateFlagSegmentRhsFeatureFlagsType$inboundSchema = z.nativeEnum(CreateFlagSegmentRhsFeatureFlagsType);
/** @internal */
export const CreateFlagSegmentItemsFeatureFlags2$inboundSchema = z.object({
    label: types.optional(types.string()),
    note: types.optional(types.string()),
    value: types.string(),
});
export function createFlagSegmentItemsFeatureFlags2FromJSON(jsonString) {
    return safeParse(jsonString, (x) => CreateFlagSegmentItemsFeatureFlags2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateFlagSegmentItemsFeatureFlags2' from JSON`);
}
/** @internal */
export const CreateFlagSegmentItemsFeatureFlags1$inboundSchema = z.object({
    label: types.optional(types.string()),
    note: types.optional(types.string()),
    value: types.number(),
});
export function createFlagSegmentItemsFeatureFlags1FromJSON(jsonString) {
    return safeParse(jsonString, (x) => CreateFlagSegmentItemsFeatureFlags1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateFlagSegmentItemsFeatureFlags1' from JSON`);
}
/** @internal */
export const CreateFlagSegmentRhsFeatureFlagsItems$inboundSchema = smartUnion([
    z.lazy(() => CreateFlagSegmentItemsFeatureFlags1$inboundSchema),
    z.lazy(() => CreateFlagSegmentItemsFeatureFlags2$inboundSchema),
]);
export function createFlagSegmentRhsFeatureFlagsItemsFromJSON(jsonString) {
    return safeParse(jsonString, (x) => CreateFlagSegmentRhsFeatureFlagsItems$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateFlagSegmentRhsFeatureFlagsItems' from JSON`);
}
/** @internal */
export const CreateFlagSegmentRhs3$inboundSchema = z.object({
    type: CreateFlagSegmentRhsFeatureFlagsType$inboundSchema,
    items: z.array(smartUnion([
        z.lazy(() => CreateFlagSegmentItemsFeatureFlags1$inboundSchema),
        z.lazy(() => CreateFlagSegmentItemsFeatureFlags2$inboundSchema),
    ])),
});
export function createFlagSegmentRhs3FromJSON(jsonString) {
    return safeParse(jsonString, (x) => CreateFlagSegmentRhs3$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateFlagSegmentRhs3' from JSON`);
}
/** @internal */
export const CreateFlagSegmentFeatureFlagsRhs$inboundSchema = smartUnion([
    z.lazy(() => CreateFlagSegmentRhs4$inboundSchema),
    z.lazy(() => CreateFlagSegmentRhs3$inboundSchema),
    types.string(),
    types.number(),
    types.boolean(),
]);
export function createFlagSegmentFeatureFlagsRhsFromJSON(jsonString) {
    return safeParse(jsonString, (x) => CreateFlagSegmentFeatureFlagsRhs$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateFlagSegmentFeatureFlagsRhs' from JSON`);
}
/** @internal */
export const CreateFlagSegmentFeatureFlagsCmpOptions$inboundSchema = z.object({
    ignoreCase: types.optional(types.boolean()),
});
export function createFlagSegmentFeatureFlagsCmpOptionsFromJSON(jsonString) {
    return safeParse(jsonString, (x) => CreateFlagSegmentFeatureFlagsCmpOptions$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateFlagSegmentFeatureFlagsCmpOptions' from JSON`);
}
/** @internal */
export const CreateFlagSegmentLhsFeatureFlags2$inboundSchema = z.object({
    type: types.literal("entity"),
    kind: types.string(),
    attribute: types.string(),
});
export function createFlagSegmentLhsFeatureFlags2FromJSON(jsonString) {
    return safeParse(jsonString, (x) => CreateFlagSegmentLhsFeatureFlags2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateFlagSegmentLhsFeatureFlags2' from JSON`);
}
/** @internal */
export const CreateFlagSegmentLhsFeatureFlags1$inboundSchema = z.object({
    type: types.literal("segment"),
});
export function createFlagSegmentLhsFeatureFlags1FromJSON(jsonString) {
    return safeParse(jsonString, (x) => CreateFlagSegmentLhsFeatureFlags1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateFlagSegmentLhsFeatureFlags1' from JSON`);
}
/** @internal */
export const CreateFlagSegmentFeatureFlagsLhs$inboundSchema = z.union([
    z.lazy(() => CreateFlagSegmentLhsFeatureFlags1$inboundSchema),
    z.lazy(() => CreateFlagSegmentLhsFeatureFlags2$inboundSchema),
]);
export function createFlagSegmentFeatureFlagsLhsFromJSON(jsonString) {
    return safeParse(jsonString, (x) => CreateFlagSegmentFeatureFlagsLhs$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateFlagSegmentFeatureFlagsLhs' from JSON`);
}
/** @internal */
export const CreateFlagSegmentFeatureFlagsCmp$inboundSchema = z.nativeEnum(CreateFlagSegmentFeatureFlagsCmp);
/** @internal */
export const CreateFlagSegmentFeatureFlagsConditions$inboundSchema = z.object({
    rhs: types.optional(smartUnion([
        z.lazy(() => CreateFlagSegmentRhs4$inboundSchema),
        z.lazy(() => CreateFlagSegmentRhs3$inboundSchema),
        types.string(),
        types.number(),
        types.boolean(),
    ])),
    cmpOptions: types.optional(z.lazy(() => CreateFlagSegmentFeatureFlagsCmpOptions$inboundSchema)),
    lhs: z.union([
        z.lazy(() => CreateFlagSegmentLhsFeatureFlags1$inboundSchema),
        z.lazy(() => CreateFlagSegmentLhsFeatureFlags2$inboundSchema),
    ]),
    cmp: CreateFlagSegmentFeatureFlagsCmp$inboundSchema,
});
export function createFlagSegmentFeatureFlagsConditionsFromJSON(jsonString) {
    return safeParse(jsonString, (x) => CreateFlagSegmentFeatureFlagsConditions$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateFlagSegmentFeatureFlagsConditions' from JSON`);
}
/** @internal */
export const CreateFlagSegmentFeatureFlagsRules$inboundSchema = z.object({
    id: types.string(),
    outcome: z.union([
        z.lazy(() => CreateFlagSegmentOutcomeFeatureFlags1$inboundSchema),
        z.lazy(() => CreateFlagSegmentOutcomeFeatureFlags2$inboundSchema),
    ]),
    conditions: z.array(z.lazy(() => CreateFlagSegmentFeatureFlagsConditions$inboundSchema)),
});
export function createFlagSegmentFeatureFlagsRulesFromJSON(jsonString) {
    return safeParse(jsonString, (x) => CreateFlagSegmentFeatureFlagsRules$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateFlagSegmentFeatureFlagsRules' from JSON`);
}
/** @internal */
export const CreateFlagSegmentFeatureFlagsInclude$inboundSchema = z.object({
    note: types.optional(types.string()),
    value: types.string(),
});
export function createFlagSegmentFeatureFlagsIncludeFromJSON(jsonString) {
    return safeParse(jsonString, (x) => CreateFlagSegmentFeatureFlagsInclude$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateFlagSegmentFeatureFlagsInclude' from JSON`);
}
/** @internal */
export const CreateFlagSegmentFeatureFlagsExclude$inboundSchema = z.object({
    note: types.optional(types.string()),
    value: types.string(),
});
export function createFlagSegmentFeatureFlagsExcludeFromJSON(jsonString) {
    return safeParse(jsonString, (x) => CreateFlagSegmentFeatureFlagsExclude$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateFlagSegmentFeatureFlagsExclude' from JSON`);
}
/** @internal */
export const CreateFlagSegmentFeatureFlagsData$inboundSchema = z.object({
    rules: types.optional(z.array(z.lazy(() => CreateFlagSegmentFeatureFlagsRules$inboundSchema))),
    include: types.optional(z.record(z.record(z.array(z.lazy(() => CreateFlagSegmentFeatureFlagsInclude$inboundSchema))))),
    exclude: types.optional(z.record(z.record(z.array(z.lazy(() => CreateFlagSegmentFeatureFlagsExclude$inboundSchema))))),
});
export function createFlagSegmentFeatureFlagsDataFromJSON(jsonString) {
    return safeParse(jsonString, (x) => CreateFlagSegmentFeatureFlagsData$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateFlagSegmentFeatureFlagsData' from JSON`);
}
/** @internal */
export const CreateFlagSegmentTypeName$inboundSchema = z.nativeEnum(CreateFlagSegmentTypeName);
/** @internal */
export const CreateFlagSegmentResponseBody$inboundSchema = z.object({
    description: types.optional(types.string()),
    createdBy: types.optional(types.string()),
    usedByFlags: types.optional(z.array(types.string())),
    usedBySegments: types.optional(z.array(types.string())),
    data: z.lazy(() => CreateFlagSegmentFeatureFlagsData$inboundSchema),
    id: types.string(),
    label: types.string(),
    slug: types.string(),
    createdAt: types.number(),
    updatedAt: types.number(),
    projectId: types.string(),
    typeName: CreateFlagSegmentTypeName$inboundSchema,
    hint: types.string(),
});
export function createFlagSegmentResponseBodyFromJSON(jsonString) {
    return safeParse(jsonString, (x) => CreateFlagSegmentResponseBody$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateFlagSegmentResponseBody' from JSON`);
}
//# sourceMappingURL=createflagsegmentop.js.map