@vercel/sdk/esm/models/createflagsegmentop.d.ts

<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>

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