unleash-server 5.2.7 → 5.3.0

package/dist/lib/openapi/spec/client-features-schema.d.ts

@@ -22,7 +22,7 @@ export declare const clientFeaturesSchema: {
             readonly description: "A list of [Segments](https://docs.getunleash.io/reference/segments) configured for this Unleash instance";
             readonly type: "array";
             readonly items: {
-                readonly $ref: "#/components/schemas/segmentSchema";
+                readonly $ref: "#/components/schemas/clientSegmentSchema";
             };
         };
         readonly query: {
@@ -185,6 +185,7 @@ export declare const clientFeaturesSchema: {
                         readonly parametersSchema: {
                             readonly $id: "#/components/schemas/parametersSchema";
                             readonly type: "object";
+                            readonly description: "A list of parameters for a strategy";
                             readonly additionalProperties: {
                                 readonly type: "string";
                             };
@@ -239,11 +240,18 @@ export declare const clientFeaturesSchema: {
                                 };
                                 readonly constraints: {
                                     readonly type: "array";
-                                    readonly description: "A list of the constraints attached to the strategy";
+                                    readonly description: "A list of the constraints attached to the strategy. See https://docs.getunleash.io/reference/strategy-constraints";
                                     readonly items: {
                                         readonly $ref: "#/components/schemas/constraintSchema";
                                     };
                                 };
+                                readonly variants: {
+                                    readonly type: "array";
+                                    readonly description: "Strategy level variants";
+                                    readonly items: {
+                                        readonly $ref: "#/components/schemas/strategyVariantSchema";
+                                    };
+                                };
                                 readonly parameters: {
                                     readonly $ref: "#/components/schemas/parametersSchema";
                                 };
@@ -297,14 +305,119 @@ export declare const clientFeaturesSchema: {
                                     readonly parametersSchema: {
                                         readonly $id: "#/components/schemas/parametersSchema";
                                         readonly type: "object";
+                                        readonly description: "A list of parameters for a strategy";
                                         readonly additionalProperties: {
                                             readonly type: "string";
                                         };
                                         readonly components: {};
                                     };
+                                    readonly strategyVariantSchema: {
+                                        readonly $id: "#/components/schemas/strategyVariantSchema";
+                                        readonly type: "object";
+                                        readonly additionalProperties: false;
+                                        readonly description: "This is an experimental property. It may change or be removed as we work on it. Please don't depend on it yet. A strategy variant allows you to attach any data to strategies instead of only returning `true`/`false`. Strategy variants take precedence over feature variants.";
+                                        readonly required: readonly ["name", "weight", "weightType", "stickiness"];
+                                        readonly properties: {
+                                            readonly name: {
+                                                readonly type: "string";
+                                                readonly description: "The variant name. Must be unique for this feature toggle";
+                                                readonly example: "blue_group";
+                                            };
+                                            readonly weight: {
+                                                readonly type: "integer";
+                                                readonly description: "The weight is the likelihood of any one user getting this variant. It is an integer between 0 and 1000. See the section on [variant weights](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight) for more information";
+                                                readonly minimum: 0;
+                                                readonly maximum: 1000;
+                                            };
+                                            readonly weightType: {
+                                                readonly description: "Set to `fix` if this variant must have exactly the weight allocated to it. If the type is `variable`, the weight will adjust so that the total weight of all variants adds up to 1000. Refer to the [variant weight documentation](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight).";
+                                                readonly type: "string";
+                                                readonly example: "fix";
+                                                readonly enum: readonly ["variable", "fix"];
+                                            };
+                                            readonly stickiness: {
+                                                readonly type: "string";
+                                                readonly description: "The [stickiness](https://docs.getunleash.io/reference/feature-toggle-variants#variant-stickiness) to use for distribution of this variant. Stickiness is how Unleash guarantees that the same user gets the same variant every time";
+                                                readonly example: "custom.context.field";
+                                            };
+                                            readonly payload: {
+                                                readonly type: "object";
+                                                readonly required: readonly ["type", "value"];
+                                                readonly description: "Extra data configured for this variant";
+                                                readonly properties: {
+                                                    readonly type: {
+                                                        readonly description: "The type of the value. Commonly used types are string, json and csv.";
+                                                        readonly type: "string";
+                                                        readonly enum: readonly ["json", "csv", "string"];
+                                                    };
+                                                    readonly value: {
+                                                        readonly description: "The actual value of payload";
+                                                        readonly type: "string";
+                                                    };
+                                                };
+                                                readonly example: {
+                                                    readonly type: "json";
+                                                    readonly value: "{\"color\": \"red\"}";
+                                                };
+                                            };
+                                        };
+                                        readonly components: {};
+                                    };
                                 };
                             };
                         };
+                        readonly strategyVariantSchema: {
+                            readonly $id: "#/components/schemas/strategyVariantSchema";
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly description: "This is an experimental property. It may change or be removed as we work on it. Please don't depend on it yet. A strategy variant allows you to attach any data to strategies instead of only returning `true`/`false`. Strategy variants take precedence over feature variants.";
+                            readonly required: readonly ["name", "weight", "weightType", "stickiness"];
+                            readonly properties: {
+                                readonly name: {
+                                    readonly type: "string";
+                                    readonly description: "The variant name. Must be unique for this feature toggle";
+                                    readonly example: "blue_group";
+                                };
+                                readonly weight: {
+                                    readonly type: "integer";
+                                    readonly description: "The weight is the likelihood of any one user getting this variant. It is an integer between 0 and 1000. See the section on [variant weights](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight) for more information";
+                                    readonly minimum: 0;
+                                    readonly maximum: 1000;
+                                };
+                                readonly weightType: {
+                                    readonly description: "Set to `fix` if this variant must have exactly the weight allocated to it. If the type is `variable`, the weight will adjust so that the total weight of all variants adds up to 1000. Refer to the [variant weight documentation](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight).";
+                                    readonly type: "string";
+                                    readonly example: "fix";
+                                    readonly enum: readonly ["variable", "fix"];
+                                };
+                                readonly stickiness: {
+                                    readonly type: "string";
+                                    readonly description: "The [stickiness](https://docs.getunleash.io/reference/feature-toggle-variants#variant-stickiness) to use for distribution of this variant. Stickiness is how Unleash guarantees that the same user gets the same variant every time";
+                                    readonly example: "custom.context.field";
+                                };
+                                readonly payload: {
+                                    readonly type: "object";
+                                    readonly required: readonly ["type", "value"];
+                                    readonly description: "Extra data configured for this variant";
+                                    readonly properties: {
+                                        readonly type: {
+                                            readonly description: "The type of the value. Commonly used types are string, json and csv.";
+                                            readonly type: "string";
+                                            readonly enum: readonly ["json", "csv", "string"];
+                                        };
+                                        readonly value: {
+                                            readonly description: "The actual value of payload";
+                                            readonly type: "string";
+                                        };
+                                    };
+                                    readonly example: {
+                                        readonly type: "json";
+                                        readonly value: "{\"color\": \"red\"}";
+                                    };
+                                };
+                            };
+                            readonly components: {};
+                        };
                         readonly variantSchema: {
                             readonly $id: "#/components/schemas/variantSchema";
                             readonly type: "object";
@@ -326,7 +439,8 @@ export declare const clientFeaturesSchema: {
                                 readonly weightType: {
                                     readonly description: "Set to fix if this variant must have exactly the weight allocated to it. If the type is variable, the weight will adjust so that the total weight of all variants adds up to 1000";
                                     readonly type: "string";
-                                    readonly example: "fix";
+                                    readonly example: "variable";
+                                    readonly enum: readonly ["variable", "fix"];
                                 };
                                 readonly stickiness: {
                                     readonly type: "string";
@@ -337,17 +451,21 @@ export declare const clientFeaturesSchema: {
                                     readonly type: "object";
                                     readonly required: readonly ["type", "value"];
                                     readonly description: "Extra data configured for this variant";
+                                    readonly additionalProperties: false;
                                     readonly properties: {
                                         readonly type: {
+                                            readonly description: "The type of the value. Commonly used types are string, json and csv.";
                                             readonly type: "string";
+                                            readonly enum: readonly ["json", "csv", "string"];
                                         };
                                         readonly value: {
+                                            readonly description: "The actual value of payload";
                                             readonly type: "string";
                                         };
                                     };
                                     readonly example: {
                                         readonly type: "json";
-                                        readonly value: "{color: red}";
+                                        readonly value: "{\"color\": \"red\"}";
                                     };
                                 };
                                 readonly overrides: {
@@ -468,10 +586,10 @@ export declare const clientFeaturesSchema: {
                 };
                 readonly components: {};
             };
-            readonly segmentSchema: {
-                readonly $id: "#/components/schemas/segmentSchema";
+            readonly clientSegmentSchema: {
+                readonly $id: "#/components/schemas/clientSegmentSchema";
                 readonly type: "object";
-                readonly description: "Represents a segment of users defined by a set of constraints.";
+                readonly description: "Represents a client API segment of users defined by a set of constraints.";
                 readonly additionalProperties: false;
                 readonly required: readonly ["id", "constraints"];
                 readonly properties: {
@@ -484,12 +602,6 @@ export declare const clientFeaturesSchema: {
                         readonly description: "The name of the segment.";
                         readonly example: "segment A";
                     };
-                    readonly description: {
-                        readonly type: "string";
-                        readonly nullable: true;
-                        readonly description: "The description of the segment.";
-                        readonly example: "Segment A description";
-                    };
                     readonly constraints: {
                         readonly type: "array";
                         readonly description: "List of constraints that determine which users are part of the segment";
@@ -617,6 +729,7 @@ export declare const clientFeaturesSchema: {
             readonly parametersSchema: {
                 readonly $id: "#/components/schemas/parametersSchema";
                 readonly type: "object";
+                readonly description: "A list of parameters for a strategy";
                 readonly additionalProperties: {
                     readonly type: "string";
                 };
@@ -671,11 +784,18 @@ export declare const clientFeaturesSchema: {
                     };
                     readonly constraints: {
                         readonly type: "array";
-                        readonly description: "A list of the constraints attached to the strategy";
+                        readonly description: "A list of the constraints attached to the strategy. See https://docs.getunleash.io/reference/strategy-constraints";
                         readonly items: {
                             readonly $ref: "#/components/schemas/constraintSchema";
                         };
                     };
+                    readonly variants: {
+                        readonly type: "array";
+                        readonly description: "Strategy level variants";
+                        readonly items: {
+                            readonly $ref: "#/components/schemas/strategyVariantSchema";
+                        };
+                    };
                     readonly parameters: {
                         readonly $ref: "#/components/schemas/parametersSchema";
                     };
@@ -729,14 +849,119 @@ export declare const clientFeaturesSchema: {
                         readonly parametersSchema: {
                             readonly $id: "#/components/schemas/parametersSchema";
                             readonly type: "object";
+                            readonly description: "A list of parameters for a strategy";
                             readonly additionalProperties: {
                                 readonly type: "string";
                             };
                             readonly components: {};
                         };
+                        readonly strategyVariantSchema: {
+                            readonly $id: "#/components/schemas/strategyVariantSchema";
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly description: "This is an experimental property. It may change or be removed as we work on it. Please don't depend on it yet. A strategy variant allows you to attach any data to strategies instead of only returning `true`/`false`. Strategy variants take precedence over feature variants.";
+                            readonly required: readonly ["name", "weight", "weightType", "stickiness"];
+                            readonly properties: {
+                                readonly name: {
+                                    readonly type: "string";
+                                    readonly description: "The variant name. Must be unique for this feature toggle";
+                                    readonly example: "blue_group";
+                                };
+                                readonly weight: {
+                                    readonly type: "integer";
+                                    readonly description: "The weight is the likelihood of any one user getting this variant. It is an integer between 0 and 1000. See the section on [variant weights](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight) for more information";
+                                    readonly minimum: 0;
+                                    readonly maximum: 1000;
+                                };
+                                readonly weightType: {
+                                    readonly description: "Set to `fix` if this variant must have exactly the weight allocated to it. If the type is `variable`, the weight will adjust so that the total weight of all variants adds up to 1000. Refer to the [variant weight documentation](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight).";
+                                    readonly type: "string";
+                                    readonly example: "fix";
+                                    readonly enum: readonly ["variable", "fix"];
+                                };
+                                readonly stickiness: {
+                                    readonly type: "string";
+                                    readonly description: "The [stickiness](https://docs.getunleash.io/reference/feature-toggle-variants#variant-stickiness) to use for distribution of this variant. Stickiness is how Unleash guarantees that the same user gets the same variant every time";
+                                    readonly example: "custom.context.field";
+                                };
+                                readonly payload: {
+                                    readonly type: "object";
+                                    readonly required: readonly ["type", "value"];
+                                    readonly description: "Extra data configured for this variant";
+                                    readonly properties: {
+                                        readonly type: {
+                                            readonly description: "The type of the value. Commonly used types are string, json and csv.";
+                                            readonly type: "string";
+                                            readonly enum: readonly ["json", "csv", "string"];
+                                        };
+                                        readonly value: {
+                                            readonly description: "The actual value of payload";
+                                            readonly type: "string";
+                                        };
+                                    };
+                                    readonly example: {
+                                        readonly type: "json";
+                                        readonly value: "{\"color\": \"red\"}";
+                                    };
+                                };
+                            };
+                            readonly components: {};
+                        };
                     };
                 };
             };
+            readonly strategyVariantSchema: {
+                readonly $id: "#/components/schemas/strategyVariantSchema";
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly description: "This is an experimental property. It may change or be removed as we work on it. Please don't depend on it yet. A strategy variant allows you to attach any data to strategies instead of only returning `true`/`false`. Strategy variants take precedence over feature variants.";
+                readonly required: readonly ["name", "weight", "weightType", "stickiness"];
+                readonly properties: {
+                    readonly name: {
+                        readonly type: "string";
+                        readonly description: "The variant name. Must be unique for this feature toggle";
+                        readonly example: "blue_group";
+                    };
+                    readonly weight: {
+                        readonly type: "integer";
+                        readonly description: "The weight is the likelihood of any one user getting this variant. It is an integer between 0 and 1000. See the section on [variant weights](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight) for more information";
+                        readonly minimum: 0;
+                        readonly maximum: 1000;
+                    };
+                    readonly weightType: {
+                        readonly description: "Set to `fix` if this variant must have exactly the weight allocated to it. If the type is `variable`, the weight will adjust so that the total weight of all variants adds up to 1000. Refer to the [variant weight documentation](https://docs.getunleash.io/reference/feature-toggle-variants#variant-weight).";
+                        readonly type: "string";
+                        readonly example: "fix";
+                        readonly enum: readonly ["variable", "fix"];
+                    };
+                    readonly stickiness: {
+                        readonly type: "string";
+                        readonly description: "The [stickiness](https://docs.getunleash.io/reference/feature-toggle-variants#variant-stickiness) to use for distribution of this variant. Stickiness is how Unleash guarantees that the same user gets the same variant every time";
+                        readonly example: "custom.context.field";
+                    };
+                    readonly payload: {
+                        readonly type: "object";
+                        readonly required: readonly ["type", "value"];
+                        readonly description: "Extra data configured for this variant";
+                        readonly properties: {
+                            readonly type: {
+                                readonly description: "The type of the value. Commonly used types are string, json and csv.";
+                                readonly type: "string";
+                                readonly enum: readonly ["json", "csv", "string"];
+                            };
+                            readonly value: {
+                                readonly description: "The actual value of payload";
+                                readonly type: "string";
+                            };
+                        };
+                        readonly example: {
+                            readonly type: "json";
+                            readonly value: "{\"color\": \"red\"}";
+                        };
+                    };
+                };
+                readonly components: {};
+            };
             readonly variantSchema: {
                 readonly $id: "#/components/schemas/variantSchema";
                 readonly type: "object";
@@ -758,7 +983,8 @@ export declare const clientFeaturesSchema: {
                     readonly weightType: {
                         readonly description: "Set to fix if this variant must have exactly the weight allocated to it. If the type is variable, the weight will adjust so that the total weight of all variants adds up to 1000";
                         readonly type: "string";
-                        readonly example: "fix";
+                        readonly example: "variable";
+                        readonly enum: readonly ["variable", "fix"];
                     };
                     readonly stickiness: {
                         readonly type: "string";
@@ -769,17 +995,21 @@ export declare const clientFeaturesSchema: {
                         readonly type: "object";
                         readonly required: readonly ["type", "value"];
                         readonly description: "Extra data configured for this variant";
+                        readonly additionalProperties: false;
                         readonly properties: {
                             readonly type: {
+                                readonly description: "The type of the value. Commonly used types are string, json and csv.";
                                 readonly type: "string";
+                                readonly enum: readonly ["json", "csv", "string"];
                             };
                             readonly value: {
+                                readonly description: "The actual value of payload";
                                 readonly type: "string";
                             };
                         };
                         readonly example: {
                             readonly type: "json";
-                            readonly value: "{color: red}";
+                            readonly value: "{\"color\": \"red\"}";
                         };
                     };
                     readonly overrides: {

package/dist/lib/openapi/spec/client-features-schema.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.clientFeaturesSchema = void 0;
 const client_features_query_schema_1 = require("./client-features-query-schema");
-const segment_schema_1 = require("./segment-schema");
+const client_segment_schema_1 = require("./client-segment-schema");
 const constraint_schema_1 = require("./constraint-schema");
 const environment_schema_1 = require("./environment-schema");
 const override_schema_1 = require("./override-schema");
@@ -10,6 +10,7 @@ const parameters_schema_1 = require("./parameters-schema");
 const feature_strategy_schema_1 = require("./feature-strategy-schema");
 const client_feature_schema_1 = require("./client-feature-schema");
 const variant_schema_1 = require("./variant-schema");
+const strategy_variant_schema_1 = require("./strategy-variant-schema");
 exports.clientFeaturesSchema = {
     $id: '#/components/schemas/clientFeaturesSchema',
     type: 'object',
@@ -33,7 +34,7 @@ exports.clientFeaturesSchema = {
             description: 'A list of [Segments](https://docs.getunleash.io/reference/segments) configured for this Unleash instance',
             type: 'array',
             items: {
-                $ref: '#/components/schemas/segmentSchema',
+                $ref: '#/components/schemas/clientSegmentSchema',
             },
         },
         query: {
@@ -46,11 +47,12 @@ exports.clientFeaturesSchema = {
             constraintSchema: constraint_schema_1.constraintSchema,
             clientFeatureSchema: client_feature_schema_1.clientFeatureSchema,
             environmentSchema: environment_schema_1.environmentSchema,
-            segmentSchema: segment_schema_1.segmentSchema,
+            clientSegmentSchema: client_segment_schema_1.clientSegmentSchema,
             clientFeaturesQuerySchema: client_features_query_schema_1.clientFeaturesQuerySchema,
             overrideSchema: override_schema_1.overrideSchema,
             parametersSchema: parameters_schema_1.parametersSchema,
             featureStrategySchema: feature_strategy_schema_1.featureStrategySchema,
+            strategyVariantSchema: strategy_variant_schema_1.strategyVariantSchema,
             variantSchema: variant_schema_1.variantSchema,
         },
     },

package/dist/lib/openapi/spec/client-features-schema.js.map

@@ -1 +1 @@
-{"version":3,"file":"client-features-schema.js","sourceRoot":"","sources":["../../../../src/lib/openapi/spec/client-features-schema.ts"],"names":[],"mappings":";;;AACA,iFAA2E;AAC3E,qDAAiD;AACjD,2DAAuD;AACvD,6DAAyD;AACzD,uDAAmD;AACnD,2DAAuD;AACvD,uEAAkE;AAClE,mEAA8D;AAC9D,qDAAiD;AAEpC,QAAA,oBAAoB,GAAG;IAChC,GAAG,EAAE,2CAA2C;IAChD,IAAI,EAAE,QAAQ;IACd,QAAQ,EAAE,CAAC,SAAS,EAAE,UAAU,CAAC;IACjC,WAAW,EACP,uEAAuE;IAC3E,UAAU,EAAE;QACR,OAAO,EAAE;YACL,IAAI,EAAE,QAAQ;YACd,WAAW,EACP,gJAAgJ;YACpJ,OAAO,EAAE,CAAC;YACV,OAAO,EAAE,CAAC;SACb;QACD,QAAQ,EAAE;YACN,WAAW,EAAE,oDAAoD;YACjE,IAAI,EAAE,OAAO;YACb,KAAK,EAAE;gBACH,IAAI,EAAE,0CAA0C;aACnD;SACJ;QACD,QAAQ,EAAE;YACN,WAAW,EACP,0GAA0G;YAC9G,IAAI,EAAE,OAAO;YACb,KAAK,EAAE;gBACH,IAAI,EAAE,oCAAoC;aAC7C;SACJ;QACD,KAAK,EAAE;YACH,WAAW,EACP,0HAA0H;YAC9H,IAAI,EAAE,gDAAgD;SACzD;KACJ;IACD,UAAU,EAAE;QACR,OAAO,EAAE;YACL,gBAAgB,EAAhB,oCAAgB;YAChB,mBAAmB,EAAnB,2CAAmB;YACnB,iBAAiB,EAAjB,sCAAiB;YACjB,aAAa,EAAb,8BAAa;YACb,yBAAyB,EAAzB,wDAAyB;YACzB,cAAc,EAAd,gCAAc;YACd,gBAAgB,EAAhB,oCAAgB;YAChB,qBAAqB,EAArB,+CAAqB;YACrB,aAAa,EAAb,8BAAa;SAChB;KACJ;CACK,CAAC"}
+{"version":3,"file":"client-features-schema.js","sourceRoot":"","sources":["../../../../src/lib/openapi/spec/client-features-schema.ts"],"names":[],"mappings":";;;AACA,iFAA2E;AAC3E,mEAA8D;AAC9D,2DAAuD;AACvD,6DAAyD;AACzD,uDAAmD;AACnD,2DAAuD;AACvD,uEAAkE;AAClE,mEAA8D;AAC9D,qDAAiD;AACjD,uEAAkE;AAErD,QAAA,oBAAoB,GAAG;IAChC,GAAG,EAAE,2CAA2C;IAChD,IAAI,EAAE,QAAQ;IACd,QAAQ,EAAE,CAAC,SAAS,EAAE,UAAU,CAAC;IACjC,WAAW,EACP,uEAAuE;IAC3E,UAAU,EAAE;QACR,OAAO,EAAE;YACL,IAAI,EAAE,QAAQ;YACd,WAAW,EACP,gJAAgJ;YACpJ,OAAO,EAAE,CAAC;YACV,OAAO,EAAE,CAAC;SACb;QACD,QAAQ,EAAE;YACN,WAAW,EAAE,oDAAoD;YACjE,IAAI,EAAE,OAAO;YACb,KAAK,EAAE;gBACH,IAAI,EAAE,0CAA0C;aACnD;SACJ;QACD,QAAQ,EAAE;YACN,WAAW,EACP,0GAA0G;YAC9G,IAAI,EAAE,OAAO;YACb,KAAK,EAAE;gBACH,IAAI,EAAE,0CAA0C;aACnD;SACJ;QACD,KAAK,EAAE;YACH,WAAW,EACP,0HAA0H;YAC9H,IAAI,EAAE,gDAAgD;SACzD;KACJ;IACD,UAAU,EAAE;QACR,OAAO,EAAE;YACL,gBAAgB,EAAhB,oCAAgB;YAChB,mBAAmB,EAAnB,2CAAmB;YACnB,iBAAiB,EAAjB,sCAAiB;YACjB,mBAAmB,EAAnB,2CAAmB;YACnB,yBAAyB,EAAzB,wDAAyB;YACzB,cAAc,EAAd,gCAAc;YACd,gBAAgB,EAAhB,oCAAgB;YAChB,qBAAqB,EAArB,+CAAqB;YACrB,qBAAqB,EAArB,+CAAqB;YACrB,aAAa,EAAb,8BAAa;SAChB;KACJ;CACK,CAAC"}

package/dist/lib/openapi/spec/client-features-schema.test.js

@@ -20,7 +20,7 @@ test('clientFeaturesSchema required fields', () => {
                         weightType: 'fix',
                         stickiness: 'c',
                         payload: {
-                            type: 'a',
+                            type: 'string',
                             value: 'b',
                         },
                         overrides: [
@@ -137,7 +137,6 @@ test('clientFeaturesSchema unleash-proxy expected response', () => {
         {
           "id": 1,
           "name": "some-name",
-          "description": null,
           "constraints": [
             {
               "contextName": "some-name",

package/dist/lib/openapi/spec/client-features-schema.test.js.map

@@ -1 +1 @@
-{"version":3,"file":"client-features-schema.test.js","sourceRoot":"","sources":["../../../../src/lib/openapi/spec/client-features-schema.test.ts"],"names":[],"mappings":";;AAAA,0CAA6C;AAG7C,IAAI,CAAC,gCAAgC,EAAE,GAAG,EAAE;IACxC,MAAM,CACF,IAAA,yBAAc,EAAC,2CAA2C,EAAE,EAAE,CAAC,CAClE,CAAC,eAAe,EAAE,CAAC;AACxB,CAAC,CAAC,CAAC;AAEH,IAAI,CAAC,sCAAsC,EAAE,GAAG,EAAE;IAC9C,MAAM,IAAI,GAAyB;QAC/B,OAAO,EAAE,CAAC;QACV,KAAK,EAAE,EAAE;QACT,QAAQ,EAAE;YACN;gBACI,IAAI,EAAE,WAAW;gBACjB,OAAO,EAAE,KAAK;gBACd,cAAc,EAAE,KAAK;gBACrB,QAAQ,EAAE;oBACN;wBACI,IAAI,EAAE,GAAG;wBACT,MAAM,EAAE,CAAC;wBACT,UAAU,EAAE,KAAK;wBACjB,UAAU,EAAE,GAAG;wBACf,OAAO,EAAE;4BACL,IAAI,EAAE,GAAG;4BACT,KAAK,EAAE,GAAG;yBACb;wBACD,SAAS,EAAE;4BACP;gCACI,WAAW,EAAE,GAAG;gCAChB,MAAM,EAAE,CAAC,GAAG,CAAC;6BAChB;yBACJ;qBACJ;iBACJ;aACJ;SACJ;KACJ,CAAC;IAEF,MAAM,CACF,IAAA,yBAAc,EAAC,2CAA2C,EAAE,IAAI,CAAC,CACpE,CAAC,aAAa,EAAE,CAAC;AACtB,CAAC,CAAC,CAAC;AAEH,IAAI,CAAC,iDAAiD,EAAE,GAAG,EAAE;IACzD,MAAM,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA0FX,CAAC;IAEH,MAAM,CACF,IAAA,yBAAc,EACV,2CAA2C,EAC3C,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CACnB,CACJ,CAAC,aAAa,EAAE,CAAC;AACtB,CAAC,CAAC,CAAC;AAEH,IAAI,CAAC,sDAAsD,EAAE,GAAG,EAAE;IAC9D,MAAM,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA6FX,CAAC;IAEH,MAAM,CACF,IAAA,yBAAc,EACV,2CAA2C,EAC3C,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CACnB,CACJ,CAAC,aAAa,EAAE,CAAC;AACtB,CAAC,CAAC,CAAC;AAEH,IAAI,CAAC,mDAAmD,EAAE,GAAG,EAAE;IAC3D,MAAM,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA6JX,CAAC;IAEH,MAAM,CACF,IAAA,yBAAc,EACV,2CAA2C,EAC3C,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CACnB,CACJ,CAAC,aAAa,EAAE,CAAC;AACtB,CAAC,CAAC,CAAC"}
+{"version":3,"file":"client-features-schema.test.js","sourceRoot":"","sources":["../../../../src/lib/openapi/spec/client-features-schema.test.ts"],"names":[],"mappings":";;AAAA,0CAA6C;AAG7C,IAAI,CAAC,gCAAgC,EAAE,GAAG,EAAE;IACxC,MAAM,CACF,IAAA,yBAAc,EAAC,2CAA2C,EAAE,EAAE,CAAC,CAClE,CAAC,eAAe,EAAE,CAAC;AACxB,CAAC,CAAC,CAAC;AAEH,IAAI,CAAC,sCAAsC,EAAE,GAAG,EAAE;IAC9C,MAAM,IAAI,GAAyB;QAC/B,OAAO,EAAE,CAAC;QACV,KAAK,EAAE,EAAE;QACT,QAAQ,EAAE;YACN;gBACI,IAAI,EAAE,WAAW;gBACjB,OAAO,EAAE,KAAK;gBACd,cAAc,EAAE,KAAK;gBACrB,QAAQ,EAAE;oBACN;wBACI,IAAI,EAAE,GAAG;wBACT,MAAM,EAAE,CAAC;wBACT,UAAU,EAAE,KAAK;wBACjB,UAAU,EAAE,GAAG;wBACf,OAAO,EAAE;4BACL,IAAI,EAAE,QAAQ;4BACd,KAAK,EAAE,GAAG;yBACb;wBACD,SAAS,EAAE;4BACP;gCACI,WAAW,EAAE,GAAG;gCAChB,MAAM,EAAE,CAAC,GAAG,CAAC;6BAChB;yBACJ;qBACJ;iBACJ;aACJ;SACJ;KACJ,CAAC;IAEF,MAAM,CACF,IAAA,yBAAc,EAAC,2CAA2C,EAAE,IAAI,CAAC,CACpE,CAAC,aAAa,EAAE,CAAC;AACtB,CAAC,CAAC,CAAC;AAEH,IAAI,CAAC,iDAAiD,EAAE,GAAG,EAAE;IACzD,MAAM,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA0FX,CAAC;IAEH,MAAM,CACF,IAAA,yBAAc,EACV,2CAA2C,EAC3C,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CACnB,CACJ,CAAC,aAAa,EAAE,CAAC;AACtB,CAAC,CAAC,CAAC;AAEH,IAAI,CAAC,sDAAsD,EAAE,GAAG,EAAE;IAC9D,MAAM,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA4FX,CAAC;IAEH,MAAM,CACF,IAAA,yBAAc,EACV,2CAA2C,EAC3C,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CACnB,CACJ,CAAC,aAAa,EAAE,CAAC;AACtB,CAAC,CAAC,CAAC;AAEH,IAAI,CAAC,mDAAmD,EAAE,GAAG,EAAE;IAC3D,MAAM,IAAI,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA6JX,CAAC;IAEH,MAAM,CACF,IAAA,yBAAc,EACV,2CAA2C,EAC3C,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CACnB,CACJ,CAAC,aAAa,EAAE,CAAC;AACtB,CAAC,CAAC,CAAC"}

package/dist/lib/openapi/spec/client-segment-schema.d.ts

@@ -0,0 +1,75 @@
+import { FromSchema } from 'json-schema-to-ts';
+export declare const clientSegmentSchema: {
+    readonly $id: "#/components/schemas/clientSegmentSchema";
+    readonly type: "object";
+    readonly description: "Represents a client API segment of users defined by a set of constraints.";
+    readonly additionalProperties: false;
+    readonly required: readonly ["id", "constraints"];
+    readonly properties: {
+        readonly id: {
+            readonly type: "number";
+            readonly description: "The segment's id.";
+        };
+        readonly name: {
+            readonly type: "string";
+            readonly description: "The name of the segment.";
+            readonly example: "segment A";
+        };
+        readonly constraints: {
+            readonly type: "array";
+            readonly description: "List of constraints that determine which users are part of the segment";
+            readonly items: {
+                readonly $ref: "#/components/schemas/constraintSchema";
+            };
+        };
+    };
+    readonly components: {
+        readonly schemas: {
+            readonly constraintSchema: {
+                readonly type: "object";
+                readonly required: readonly ["contextName", "operator"];
+                readonly description: "A strategy constraint. For more information, refer to [the strategy constraint reference documentation](https://docs.getunleash.io/reference/strategy-constraints)";
+                readonly properties: {
+                    readonly contextName: {
+                        readonly description: "The name of the context field that this constraint should apply to.";
+                        readonly example: "appName";
+                        readonly type: "string";
+                    };
+                    readonly operator: {
+                        readonly description: "The operator to use when evaluating this constraint. For more information about the various operators, refer to [the strategy constraint operator documentation](https://docs.getunleash.io/reference/strategy-constraints#strategy-constraint-operators).";
+                        readonly type: "string";
+                        readonly enum: readonly ["NOT_IN", "IN", "STR_ENDS_WITH", "STR_STARTS_WITH", "STR_CONTAINS", "NUM_EQ", "NUM_GT", "NUM_GTE", "NUM_LT", "NUM_LTE", "DATE_AFTER", "DATE_BEFORE", "SEMVER_EQ", "SEMVER_GT", "SEMVER_LT"];
+                        readonly example: "IN";
+                    };
+                    readonly caseInsensitive: {
+                        readonly description: "Whether the operator should be case sensitive or not. Defaults to `false` (being case sensitive).";
+                        readonly type: "boolean";
+                        readonly default: false;
+                    };
+                    readonly inverted: {
+                        readonly description: "Whether the result should be negated or not. If `true`, will turn a `true` result into a `false` result and vice versa.";
+                        readonly type: "boolean";
+                        readonly default: false;
+                    };
+                    readonly values: {
+                        readonly type: "array";
+                        readonly description: "The context values that should be used for constraint evaluation. Use this property instead of `value` for properties that accept multiple values.";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly example: readonly ["my-app", "my-other-app"];
+                    };
+                    readonly value: {
+                        readonly description: "The context value that should be used for constraint evaluation. Use this property instead of `values` for properties that only accept single values.";
+                        readonly type: "string";
+                        readonly example: "my-app";
+                    };
+                };
+                readonly components: {};
+                readonly $id: "#/components/schemas/constraintSchema";
+                readonly additionalProperties: false;
+            };
+        };
+    };
+};
+export declare type ClientSegmentSchema = FromSchema<typeof clientSegmentSchema>;

package/dist/lib/openapi/spec/client-segment-schema.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clientSegmentSchema = void 0;
+const constraint_schema_1 = require("./constraint-schema");
+exports.clientSegmentSchema = {
+    $id: '#/components/schemas/clientSegmentSchema',
+    type: 'object',
+    description: 'Represents a client API segment of users defined by a set of constraints.',
+    additionalProperties: false,
+    required: ['id', 'constraints'],
+    properties: {
+        id: {
+            type: 'number',
+            description: "The segment's id.",
+        },
+        name: {
+            type: 'string',
+            description: 'The name of the segment.',
+            example: 'segment A',
+        },
+        constraints: {
+            type: 'array',
+            description: 'List of constraints that determine which users are part of the segment',
+            items: {
+                $ref: '#/components/schemas/constraintSchema',
+            },
+        },
+    },
+    components: {
+        schemas: {
+            constraintSchema: constraint_schema_1.constraintSchema,
+        },
+    },
+};
+//# sourceMappingURL=client-segment-schema.js.map

package/dist/lib/openapi/spec/client-segment-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-segment-schema.js","sourceRoot":"","sources":["../../../../src/lib/openapi/spec/client-segment-schema.ts"],"names":[],"mappings":";;;AACA,2DAAuD;AAE1C,QAAA,mBAAmB,GAAG;IAC/B,GAAG,EAAE,0CAA0C;IAC/C,IAAI,EAAE,QAAQ;IACd,WAAW,EACP,2EAA2E;IAC/E,oBAAoB,EAAE,KAAK;IAC3B,QAAQ,EAAE,CAAC,IAAI,EAAE,aAAa,CAAC;IAC/B,UAAU,EAAE;QACR,EAAE,EAAE;YACA,IAAI,EAAE,QAAQ;YACd,WAAW,EAAE,mBAAmB;SACnC;QACD,IAAI,EAAE;YACF,IAAI,EAAE,QAAQ;YACd,WAAW,EAAE,0BAA0B;YACvC,OAAO,EAAE,WAAW;SACvB;QACD,WAAW,EAAE;YACT,IAAI,EAAE,OAAO;YACb,WAAW,EACP,wEAAwE;YAC5E,KAAK,EAAE;gBACH,IAAI,EAAE,uCAAuC;aAChD;SACJ;KACJ;IACD,UAAU,EAAE;QACR,OAAO,EAAE;YACL,gBAAgB,EAAhB,oCAAgB;SACnB;KACJ;CACK,CAAC"}

package/dist/lib/openapi/spec/clone-feature-schema.d.ts

@@ -3,12 +3,17 @@ export declare const cloneFeatureSchema: {
     readonly $id: "#/components/schemas/cloneFeatureSchema";
     readonly type: "object";
     readonly required: readonly ["name"];
+    readonly description: "Copy of a feature with a new name";
     readonly properties: {
         readonly name: {
             readonly type: "string";
+            readonly description: "The name of the new feature";
+            readonly example: "new-feature";
         };
         readonly replaceGroupId: {
             readonly type: "boolean";
+            readonly example: true;
+            readonly description: "Whether to use the new feature name as its group ID or not. Group ID is used for calculating [stickiness](https://docs.getunleash.io/reference/stickiness#calculation). Defaults to true.";
         };
     };
     readonly components: {};

package/dist/lib/openapi/spec/clone-feature-schema.js

@@ -5,12 +5,17 @@ exports.cloneFeatureSchema = {
     $id: '#/components/schemas/cloneFeatureSchema',
     type: 'object',
     required: ['name'],
+    description: 'Copy of a feature with a new name',
     properties: {
         name: {
             type: 'string',
+            description: 'The name of the new feature',
+            example: 'new-feature',
         },
         replaceGroupId: {
             type: 'boolean',
+            example: true,
+            description: 'Whether to use the new feature name as its group ID or not. Group ID is used for calculating [stickiness](https://docs.getunleash.io/reference/stickiness#calculation). Defaults to true.',
         },
     },
     components: {},

package/dist/lib/openapi/spec/clone-feature-schema.js.map

@@ -1 +1 @@
-{"version":3,"file":"clone-feature-schema.js","sourceRoot":"","sources":["../../../../src/lib/openapi/spec/clone-feature-schema.ts"],"names":[],"mappings":";;;AAEa,QAAA,kBAAkB,GAAG;IAC9B,GAAG,EAAE,yCAAyC;IAC9C,IAAI,EAAE,QAAQ;IACd,QAAQ,EAAE,CAAC,MAAM,CAAC;IAClB,UAAU,EAAE;QACR,IAAI,EAAE;YACF,IAAI,EAAE,QAAQ;SACjB;QACD,cAAc,EAAE;YACZ,IAAI,EAAE,SAAS;SAClB;KACJ;IACD,UAAU,EAAE,EAAE;CACR,CAAC"}
+{"version":3,"file":"clone-feature-schema.js","sourceRoot":"","sources":["../../../../src/lib/openapi/spec/clone-feature-schema.ts"],"names":[],"mappings":";;;AAEa,QAAA,kBAAkB,GAAG;IAC9B,GAAG,EAAE,yCAAyC;IAC9C,IAAI,EAAE,QAAQ;IACd,QAAQ,EAAE,CAAC,MAAM,CAAC;IAClB,WAAW,EAAE,mCAAmC;IAChD,UAAU,EAAE;QACR,IAAI,EAAE;YACF,IAAI,EAAE,QAAQ;YACd,WAAW,EAAE,6BAA6B;YAC1C,OAAO,EAAE,aAAa;SACzB;QACD,cAAc,EAAE;YACZ,IAAI,EAAE,SAAS;YACf,OAAO,EAAE,IAAI;YACb,WAAW,EACP,2LAA2L;SAClM;KACJ;IACD,UAAU,EAAE,EAAE;CACR,CAAC"}