unleash-server 4.14.2 → 4.14.4

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

@@ -26,35 +26,45 @@ export declare const clientFeaturesSchema: {
     readonly components: {
         readonly schemas: {
             readonly constraintSchema: {
-                readonly $id: "#/components/schemas/constraintSchema";
                 readonly type: "object";
-                readonly additionalProperties: false;
                 readonly required: readonly ["contextName", "operator"];
+                readonly description: "A strategy constraint. For more information, refer to [the strategy constraint reference documentation](https://docs.getunleash.io/advanced/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/advanced/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 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 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 components: {};
+                readonly $id: "#/components/schemas/constraintSchema";
+                readonly additionalProperties: false;
             };
             readonly clientFeatureSchema: {
                 readonly $id: "#/components/schemas/clientFeatureSchema";
@@ -104,7 +114,7 @@ export declare const clientFeaturesSchema: {
                     readonly variants: {
                         readonly type: "array";
                         readonly items: {
-                            readonly $ref: "#/components/schemas/clientVariantSchema";
+                            readonly $ref: "#/components/schemas/variantSchema";
                         };
                         readonly nullable: true;
                     };
@@ -112,35 +122,45 @@ export declare const clientFeaturesSchema: {
                 readonly components: {
                     readonly schemas: {
                         readonly constraintSchema: {
-                            readonly $id: "#/components/schemas/constraintSchema";
                             readonly type: "object";
-                            readonly additionalProperties: false;
                             readonly required: readonly ["contextName", "operator"];
+                            readonly description: "A strategy constraint. For more information, refer to [the strategy constraint reference documentation](https://docs.getunleash.io/advanced/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/advanced/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 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 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 components: {};
+                            readonly $id: "#/components/schemas/constraintSchema";
+                            readonly additionalProperties: false;
                         };
                         readonly parametersSchema: {
                             readonly $id: "#/components/schemas/parametersSchema";
@@ -184,35 +204,45 @@ export declare const clientFeaturesSchema: {
                             readonly components: {
                                 readonly schemas: {
                                     readonly constraintSchema: {
-                                        readonly $id: "#/components/schemas/constraintSchema";
                                         readonly type: "object";
-                                        readonly additionalProperties: false;
                                         readonly required: readonly ["contextName", "operator"];
+                                        readonly description: "A strategy constraint. For more information, refer to [the strategy constraint reference documentation](https://docs.getunleash.io/advanced/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/advanced/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 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 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 components: {};
+                                        readonly $id: "#/components/schemas/constraintSchema";
+                                        readonly additionalProperties: false;
                                     };
                                     readonly parametersSchema: {
                                         readonly $id: "#/components/schemas/parametersSchema";
@@ -225,8 +255,8 @@ export declare const clientFeaturesSchema: {
                                 };
                             };
                         };
-                        readonly clientVariantSchema: {
-                            readonly $id: "#/components/schemas/clientVariantSchema";
+                        readonly variantSchema: {
+                            readonly $id: "#/components/schemas/variantSchema";
                             readonly type: "object";
                             readonly additionalProperties: false;
                             readonly required: readonly ["name", "weight"];
@@ -255,6 +285,51 @@ export declare const clientFeaturesSchema: {
                                         };
                                     };
                                 };
+                                readonly overrides: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly $ref: "#/components/schemas/overrideSchema";
+                                    };
+                                };
+                            };
+                            readonly components: {
+                                readonly schemas: {
+                                    readonly overrideSchema: {
+                                        readonly $id: "#/components/schemas/overrideSchema";
+                                        readonly type: "object";
+                                        readonly additionalProperties: false;
+                                        readonly required: readonly ["contextName", "values"];
+                                        readonly properties: {
+                                            readonly contextName: {
+                                                readonly type: "string";
+                                            };
+                                            readonly values: {
+                                                readonly type: "array";
+                                                readonly items: {
+                                                    readonly type: "string";
+                                                };
+                                            };
+                                        };
+                                        readonly components: {};
+                                    };
+                                };
+                            };
+                        };
+                        readonly overrideSchema: {
+                            readonly $id: "#/components/schemas/overrideSchema";
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly required: readonly ["contextName", "values"];
+                            readonly properties: {
+                                readonly contextName: {
+                                    readonly type: "string";
+                                };
+                                readonly values: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "string";
+                                    };
+                                };
                             };
                             readonly components: {};
                         };
@@ -311,35 +386,45 @@ export declare const clientFeaturesSchema: {
                 readonly components: {
                     readonly schemas: {
                         readonly constraintSchema: {
-                            readonly $id: "#/components/schemas/constraintSchema";
                             readonly type: "object";
-                            readonly additionalProperties: false;
                             readonly required: readonly ["contextName", "operator"];
+                            readonly description: "A strategy constraint. For more information, refer to [the strategy constraint reference documentation](https://docs.getunleash.io/advanced/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/advanced/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 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 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 components: {};
+                            readonly $id: "#/components/schemas/constraintSchema";
+                            readonly additionalProperties: false;
                         };
                     };
                 };
@@ -436,35 +521,45 @@ export declare const clientFeaturesSchema: {
                 readonly components: {
                     readonly schemas: {
                         readonly constraintSchema: {
-                            readonly $id: "#/components/schemas/constraintSchema";
                             readonly type: "object";
-                            readonly additionalProperties: false;
                             readonly required: readonly ["contextName", "operator"];
+                            readonly description: "A strategy constraint. For more information, refer to [the strategy constraint reference documentation](https://docs.getunleash.io/advanced/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/advanced/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 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 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 components: {};
+                            readonly $id: "#/components/schemas/constraintSchema";
+                            readonly additionalProperties: false;
                         };
                         readonly parametersSchema: {
                             readonly $id: "#/components/schemas/parametersSchema";
@@ -477,8 +572,8 @@ export declare const clientFeaturesSchema: {
                     };
                 };
             };
-            readonly clientVariantSchema: {
-                readonly $id: "#/components/schemas/clientVariantSchema";
+            readonly variantSchema: {
+                readonly $id: "#/components/schemas/variantSchema";
                 readonly type: "object";
                 readonly additionalProperties: false;
                 readonly required: readonly ["name", "weight"];
@@ -507,8 +602,35 @@ export declare const clientFeaturesSchema: {
                             };
                         };
                     };
+                    readonly overrides: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly $ref: "#/components/schemas/overrideSchema";
+                        };
+                    };
+                };
+                readonly components: {
+                    readonly schemas: {
+                        readonly overrideSchema: {
+                            readonly $id: "#/components/schemas/overrideSchema";
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly required: readonly ["contextName", "values"];
+                            readonly properties: {
+                                readonly contextName: {
+                                    readonly type: "string";
+                                };
+                                readonly values: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "string";
+                                    };
+                                };
+                            };
+                            readonly components: {};
+                        };
+                    };
                 };
-                readonly components: {};
             };
         };
     };

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

@@ -9,7 +9,7 @@ const override_schema_1 = require("./override-schema");
 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 client_variant_schema_1 = require("./client-variant-schema");
+const variant_schema_1 = require("./variant-schema");
 exports.clientFeaturesSchema = {
     $id: '#/components/schemas/clientFeaturesSchema',
     type: 'object',
@@ -44,7 +44,7 @@ exports.clientFeaturesSchema = {
             overrideSchema: override_schema_1.overrideSchema,
             parametersSchema: parameters_schema_1.parametersSchema,
             featureStrategySchema: feature_strategy_schema_1.featureStrategySchema,
-            clientVariantSchema: client_variant_schema_1.clientVariantSchema,
+            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,mEAA8D;AAEjD,QAAA,oBAAoB,GAAG;IAChC,GAAG,EAAE,2CAA2C;IAChD,IAAI,EAAE,QAAQ;IACd,QAAQ,EAAE,CAAC,SAAS,EAAE,UAAU,CAAC;IACjC,UAAU,EAAE;QACR,OAAO,EAAE;YACL,IAAI,EAAE,QAAQ;SACjB;QACD,QAAQ,EAAE;YACN,IAAI,EAAE,OAAO;YACb,KAAK,EAAE;gBACH,IAAI,EAAE,0CAA0C;aACnD;SACJ;QACD,QAAQ,EAAE;YACN,IAAI,EAAE,OAAO;YACb,KAAK,EAAE;gBACH,IAAI,EAAE,oCAAoC;aAC7C;SACJ;QACD,KAAK,EAAE;YACH,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,mBAAmB,EAAnB,2CAAmB;SACtB;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,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,UAAU,EAAE;QACR,OAAO,EAAE;YACL,IAAI,EAAE,QAAQ;SACjB;QACD,QAAQ,EAAE;YACN,IAAI,EAAE,OAAO;YACb,KAAK,EAAE;gBACH,IAAI,EAAE,0CAA0C;aACnD;SACJ;QACD,QAAQ,EAAE;YACN,IAAI,EAAE,OAAO;YACb,KAAK,EAAE;gBACH,IAAI,EAAE,oCAAoC;aAC7C;SACJ;QACD,KAAK,EAAE;YACH,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"}

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

@@ -19,6 +19,16 @@ test('clientFeaturesSchema required fields', () => {
                         weight: 1,
                         weightType: 'b',
                         stickiness: 'c',
+                        payload: {
+                            type: 'a',
+                            value: 'b',
+                        },
+                        overrides: [
+                            {
+                                contextName: 'a',
+                                values: ['b'],
+                            },
+                        ],
                     },
                 ],
             },

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,GAAG;wBACf,UAAU,EAAE,GAAG;qBAClB;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+FX,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+FX,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,GAAG;wBACf,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+FX,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+FX,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/constraint-schema.d.ts

@@ -1,33 +1,82 @@
 import { FromSchema } from 'json-schema-to-ts';
+export declare const constraintSchemaBase: {
+    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/advanced/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/advanced/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 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 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 components: {};
+};
 export declare const constraintSchema: {
-    readonly $id: "#/components/schemas/constraintSchema";
     readonly type: "object";
-    readonly additionalProperties: false;
     readonly required: readonly ["contextName", "operator"];
+    readonly description: "A strategy constraint. For more information, refer to [the strategy constraint reference documentation](https://docs.getunleash.io/advanced/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/advanced/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 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 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 components: {};
+    readonly $id: "#/components/schemas/constraintSchema";
+    readonly additionalProperties: false;
 };
 export declare type ConstraintSchema = FromSchema<typeof constraintSchema>;

package/dist/lib/openapi/spec/constraint-schema.js

@@ -1,36 +1,49 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.constraintSchema = void 0;
+exports.constraintSchema = exports.constraintSchemaBase = void 0;
 const constants_1 = require("../../util/constants");
-exports.constraintSchema = {
-    $id: '#/components/schemas/constraintSchema',
+exports.constraintSchemaBase = {
     type: 'object',
-    additionalProperties: false,
     required: ['contextName', 'operator'],
+    description: 'A strategy constraint. For more information, refer to [the strategy constraint reference documentation](https://docs.getunleash.io/advanced/strategy_constraints)',
     properties: {
         contextName: {
+            description: 'The name of the context field that this constraint should apply to.',
+            example: 'appName',
             type: 'string',
         },
         operator: {
+            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/advanced/strategy_constraints#strategy-constraint-operators).',
             type: 'string',
             enum: constants_1.ALL_OPERATORS,
         },
         caseInsensitive: {
+            description: 'Whether the operator should be case sensitive or not. Defaults to `false` (being case sensitive).',
             type: 'boolean',
+            default: false,
         },
         inverted: {
+            description: 'Whether the result should be negated or not. If `true`, will turn a `true` result into a `false` result and vice versa.',
             type: 'boolean',
+            default: false,
         },
         values: {
             type: 'array',
+            description: 'The context values that should be used for constraint evaluation. Use this property instead of `value` for properties that accept multiple values.',
             items: {
                 type: 'string',
             },
         },
         value: {
+            description: 'The context value that should be used for constraint evaluation. Use this property instead of `values` for properties that only accept single values.',
             type: 'string',
         },
     },
     components: {},
 };
+exports.constraintSchema = {
+    $id: '#/components/schemas/constraintSchema',
+    additionalProperties: false,
+    ...exports.constraintSchemaBase,
+};
 //# sourceMappingURL=constraint-schema.js.map

package/dist/lib/openapi/spec/constraint-schema.js.map

@@ -1 +1 @@
-{"version":3,"file":"constraint-schema.js","sourceRoot":"","sources":["../../../../src/lib/openapi/spec/constraint-schema.ts"],"names":[],"mappings":";;;AACA,oDAAqD;AAExC,QAAA,gBAAgB,GAAG;IAC5B,GAAG,EAAE,uCAAuC;IAC5C,IAAI,EAAE,QAAQ;IACd,oBAAoB,EAAE,KAAK;IAC3B,QAAQ,EAAE,CAAC,aAAa,EAAE,UAAU,CAAC;IACrC,UAAU,EAAE;QACR,WAAW,EAAE;YACT,IAAI,EAAE,QAAQ;SACjB;QACD,QAAQ,EAAE;YACN,IAAI,EAAE,QAAQ;YACd,IAAI,EAAE,yBAAa;SACtB;QACD,eAAe,EAAE;YACb,IAAI,EAAE,SAAS;SAClB;QACD,QAAQ,EAAE;YACN,IAAI,EAAE,SAAS;SAClB;QACD,MAAM,EAAE;YACJ,IAAI,EAAE,OAAO;YACb,KAAK,EAAE;gBACH,IAAI,EAAE,QAAQ;aACjB;SACJ;QACD,KAAK,EAAE;YACH,IAAI,EAAE,QAAQ;SACjB;KACJ;IACD,UAAU,EAAE,EAAE;CACR,CAAC"}
+{"version":3,"file":"constraint-schema.js","sourceRoot":"","sources":["../../../../src/lib/openapi/spec/constraint-schema.ts"],"names":[],"mappings":";;;AACA,oDAAqD;AAExC,QAAA,oBAAoB,GAAG;IAChC,IAAI,EAAE,QAAQ;IACd,QAAQ,EAAE,CAAC,aAAa,EAAE,UAAU,CAAC;IACrC,WAAW,EACP,mKAAmK;IACvK,UAAU,EAAE;QACR,WAAW,EAAE;YACT,WAAW,EACP,qEAAqE;YACzE,OAAO,EAAE,SAAS;YAClB,IAAI,EAAE,QAAQ;SACjB;QACD,QAAQ,EAAE;YACN,WAAW,EACP,2PAA2P;YAC/P,IAAI,EAAE,QAAQ;YACd,IAAI,EAAE,yBAAa;SACtB;QACD,eAAe,EAAE;YACb,WAAW,EACP,mGAAmG;YACvG,IAAI,EAAE,SAAS;YACf,OAAO,EAAE,KAAK;SACjB;QACD,QAAQ,EAAE;YACN,WAAW,EACP,yHAAyH;YAC7H,IAAI,EAAE,SAAS;YACf,OAAO,EAAE,KAAK;SACjB;QACD,MAAM,EAAE;YACJ,IAAI,EAAE,OAAO;YACb,WAAW,EACP,oJAAoJ;YACxJ,KAAK,EAAE;gBACH,IAAI,EAAE,QAAQ;aACjB;SACJ;QACD,KAAK,EAAE;YACH,WAAW,EACP,uJAAuJ;YAC3J,IAAI,EAAE,QAAQ;SACjB;KACJ;IACD,UAAU,EAAE,EAAE;CACR,CAAC;AAEE,QAAA,gBAAgB,GAAG;IAC5B,GAAG,EAAE,uCAAuC;IAC5C,oBAAoB,EAAE,KAAK;IAC3B,GAAG,4BAAoB;CACjB,CAAC"}

package/dist/lib/openapi/spec/context-field-schema.test.js

@@ -8,7 +8,11 @@ test('contextFieldSchema', () => {
         stickiness: false,
         sortOrder: 0,
         createdAt: '2022-01-01T00:00:00.000Z',
-        legalValues: [],
+        legalValues: [
+            { value: 'a' },
+            { value: 'b', description: '' },
+            { value: 'c', description: 'd' },
+        ],
     };
     expect((0, validate_1.validateSchema)('#/components/schemas/contextFieldSchema', data)).toBeUndefined();
 });

package/dist/lib/openapi/spec/context-field-schema.test.js.map

@@ -1 +1 @@
-{"version":3,"file":"context-field-schema.test.js","sourceRoot":"","sources":["../../../../src/lib/openapi/spec/context-field-schema.test.ts"],"names":[],"mappings":";;AAAA,0CAA6C;AAG7C,IAAI,CAAC,oBAAoB,EAAE,GAAG,EAAE;IAC5B,MAAM,IAAI,GAAuB;QAC7B,IAAI,EAAE,EAAE;QACR,WAAW,EAAE,EAAE;QACf,UAAU,EAAE,KAAK;QACjB,SAAS,EAAE,CAAC;QACZ,SAAS,EAAE,0BAA0B;QACrC,WAAW,EAAE,EAAE;KAClB,CAAC;IAEF,MAAM,CACF,IAAA,yBAAc,EAAC,yCAAyC,EAAE,IAAI,CAAC,CAClE,CAAC,aAAa,EAAE,CAAC;AACtB,CAAC,CAAC,CAAC;AAEH,IAAI,CAAC,0BAA0B,EAAE,GAAG,EAAE;IAClC,MAAM,CACF,IAAA,yBAAc,EAAC,yCAAyC,EAAE,EAAE,CAAC,CAChE,CAAC,eAAe,EAAE,CAAC;AACxB,CAAC,CAAC,CAAC"}
+{"version":3,"file":"context-field-schema.test.js","sourceRoot":"","sources":["../../../../src/lib/openapi/spec/context-field-schema.test.ts"],"names":[],"mappings":";;AAAA,0CAA6C;AAG7C,IAAI,CAAC,oBAAoB,EAAE,GAAG,EAAE;IAC5B,MAAM,IAAI,GAAuB;QAC7B,IAAI,EAAE,EAAE;QACR,WAAW,EAAE,EAAE;QACf,UAAU,EAAE,KAAK;QACjB,SAAS,EAAE,CAAC;QACZ,SAAS,EAAE,0BAA0B;QACrC,WAAW,EAAE;YACT,EAAE,KAAK,EAAE,GAAG,EAAE;YACd,EAAE,KAAK,EAAE,GAAG,EAAE,WAAW,EAAE,EAAE,EAAE;YAC/B,EAAE,KAAK,EAAE,GAAG,EAAE,WAAW,EAAE,GAAG,EAAE;SACnC;KACJ,CAAC;IAEF,MAAM,CACF,IAAA,yBAAc,EAAC,yCAAyC,EAAE,IAAI,CAAC,CAClE,CAAC,aAAa,EAAE,CAAC;AACtB,CAAC,CAAC,CAAC;AAEH,IAAI,CAAC,0BAA0B,EAAE,GAAG,EAAE;IAClC,MAAM,CACF,IAAA,yBAAc,EAAC,yCAAyC,EAAE,EAAE,CAAC,CAChE,CAAC,eAAe,EAAE,CAAC;AACxB,CAAC,CAAC,CAAC"}

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

@@ -23,35 +23,45 @@ export declare const createFeatureStrategySchema: {
     readonly components: {
         readonly schemas: {
             readonly constraintSchema: {
-                readonly $id: "#/components/schemas/constraintSchema";
                 readonly type: "object";
-                readonly additionalProperties: false;
                 readonly required: readonly ["contextName", "operator"];
+                readonly description: "A strategy constraint. For more information, refer to [the strategy constraint reference documentation](https://docs.getunleash.io/advanced/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/advanced/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 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 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 components: {};
+                readonly $id: "#/components/schemas/constraintSchema";
+                readonly additionalProperties: false;
             };
             readonly parametersSchema: {
                 readonly $id: "#/components/schemas/parametersSchema";