unleash-server 4.11.2 → 4.12.0-beta.2

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

@@ -1 +1 @@
-{"version":3,"file":"create-feature-schema.js","sourceRoot":"","sources":["../../../../src/lib/openapi/spec/create-feature-schema.ts"],"names":[],"mappings":";;;AAAA,oCAAgE;AAEhE,MAAM,MAAM,GAAG;IACX,IAAI,EAAE,QAAQ;IACd,QAAQ,EAAE,CAAC,MAAM,CAAC;IAClB,UAAU,EAAE;QACR,IAAI,EAAE;YACF,IAAI,EAAE,QAAQ;SACjB;QACD,IAAI,EAAE;YACF,IAAI,EAAE,QAAQ;SACjB;QACD,WAAW,EAAE;YACT,IAAI,EAAE,QAAQ;SACjB;QACD,cAAc,EAAE;YACZ,IAAI,EAAE,SAAS;SAClB;KACJ;CACK,CAAC;AAIE,QAAA,mBAAmB,GAAG,IAAA,0BAAkB,EAAC,MAAM,CAAC,CAAC"}
+{"version":3,"file":"create-feature-schema.js","sourceRoot":"","sources":["../../../../src/lib/openapi/spec/create-feature-schema.ts"],"names":[],"mappings":";;;AAAA,oCAAgE;AAEhE,MAAM,MAAM,GAAG;IACX,IAAI,EAAE,QAAQ;IACd,QAAQ,EAAE,CAAC,MAAM,CAAC;IAClB,UAAU,EAAE;QACR,IAAI,EAAE;YACF,IAAI,EAAE,QAAQ;SACjB;QACD,IAAI,EAAE;YACF,IAAI,EAAE,QAAQ;SACjB;QACD,WAAW,EAAE;YACT,IAAI,EAAE,QAAQ;SACjB;QACD,cAAc,EAAE;YACZ,IAAI,EAAE,SAAS;SAClB;KACJ;IACD,oBAAoB,EAAE,EAAE;CAClB,CAAC;AAIE,QAAA,mBAAmB,GAAG,IAAA,0BAAkB,EAAC,MAAM,CAAC,CAAC"}

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

@@ -2,6 +2,7 @@ import { CreateSchemaType } from '../types';
 declare const schema: {
     readonly type: "object";
     readonly additionalProperties: false;
+    readonly required: readonly ["name"];
     readonly properties: {
         readonly name: {
             readonly type: "string";
@@ -11,47 +12,59 @@ declare const schema: {
         };
         readonly constraints: {
             readonly type: "array";
-            readonly items: import("../../types/mutable").DeepMutable<{
-                readonly type: "object";
-                readonly additionalProperties: false;
-                readonly required: readonly ["contextName", "operator"];
-                readonly properties: {
-                    readonly contextName: {
-                        readonly type: "string";
-                    };
-                    readonly operator: {
-                        readonly type: "string";
-                    };
-                    readonly caseInsensitive: {
-                        readonly type: "boolean";
-                    };
-                    readonly inverted: {
-                        readonly type: "boolean";
-                    };
-                    readonly values: {
-                        readonly type: "array";
-                        readonly items: {
-                            readonly type: "string";
-                        };
-                    };
-                    readonly value: {
+            readonly items: {
+                readonly $ref: "#/components/schemas/constraintSchema";
+            };
+        };
+        readonly parameters: {
+            readonly $ref: "#/components/schemas/parametersSchema";
+        };
+    };
+    readonly 'components/schemas': {
+        readonly constraintSchema: import("../../types/mutable").DeepMutable<Omit<{
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["contextName", "operator"];
+            readonly properties: {
+                readonly contextName: {
+                    readonly type: "string";
+                };
+                readonly operator: {
+                    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 type: "boolean";
+                };
+                readonly inverted: {
+                    readonly type: "boolean";
+                };
+                readonly values: {
+                    readonly type: "array";
+                    readonly items: {
                         readonly type: "string";
                     };
                 };
-            }>;
-        };
-        readonly parameters: import("../../types/mutable").DeepMutable<{
+                readonly value: {
+                    readonly type: "string";
+                };
+            };
+            readonly 'components/schemas': {};
+        }, "components/schemas">>;
+        readonly parametersSchema: import("../../types/mutable").DeepMutable<Omit<{
             readonly type: "object";
             readonly additionalProperties: {
                 readonly type: "string";
             };
-        }>;
+            readonly 'components/schemas': {};
+        }, "components/schemas">>;
     };
 };
 export declare type CreateStrategySchema = CreateSchemaType<typeof schema>;
-export declare const createStrategySchema: import("../../types/mutable").DeepMutable<{
+export declare const createStrategySchema: import("../../types/mutable").DeepMutable<Omit<{
     readonly type: "object";
     readonly additionalProperties: false;
+    readonly required: readonly ["name"];
     readonly properties: {
         readonly name: {
             readonly type: "string";
@@ -61,41 +74,52 @@ export declare const createStrategySchema: import("../../types/mutable").DeepMut
         };
         readonly constraints: {
             readonly type: "array";
-            readonly items: import("../../types/mutable").DeepMutable<{
-                readonly type: "object";
-                readonly additionalProperties: false;
-                readonly required: readonly ["contextName", "operator"];
-                readonly properties: {
-                    readonly contextName: {
-                        readonly type: "string";
-                    };
-                    readonly operator: {
-                        readonly type: "string";
-                    };
-                    readonly caseInsensitive: {
-                        readonly type: "boolean";
-                    };
-                    readonly inverted: {
-                        readonly type: "boolean";
-                    };
-                    readonly values: {
-                        readonly type: "array";
-                        readonly items: {
-                            readonly type: "string";
-                        };
-                    };
-                    readonly value: {
+            readonly items: {
+                readonly $ref: "#/components/schemas/constraintSchema";
+            };
+        };
+        readonly parameters: {
+            readonly $ref: "#/components/schemas/parametersSchema";
+        };
+    };
+    readonly 'components/schemas': {
+        readonly constraintSchema: import("../../types/mutable").DeepMutable<Omit<{
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["contextName", "operator"];
+            readonly properties: {
+                readonly contextName: {
+                    readonly type: "string";
+                };
+                readonly operator: {
+                    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 type: "boolean";
+                };
+                readonly inverted: {
+                    readonly type: "boolean";
+                };
+                readonly values: {
+                    readonly type: "array";
+                    readonly items: {
                         readonly type: "string";
                     };
                 };
-            }>;
-        };
-        readonly parameters: import("../../types/mutable").DeepMutable<{
+                readonly value: {
+                    readonly type: "string";
+                };
+            };
+            readonly 'components/schemas': {};
+        }, "components/schemas">>;
+        readonly parametersSchema: import("../../types/mutable").DeepMutable<Omit<{
             readonly type: "object";
             readonly additionalProperties: {
                 readonly type: "string";
             };
-        }>;
+            readonly 'components/schemas': {};
+        }, "components/schemas">>;
     };
-}>;
+}, "components/schemas">>;
 export {};

package/dist/lib/openapi/spec/create-strategy-schema.js

@@ -7,6 +7,7 @@ const constraint_schema_1 = require("./constraint-schema");
 const schema = {
     type: 'object',
     additionalProperties: false,
+    required: ['name'],
     properties: {
         name: {
             type: 'string',
@@ -16,9 +17,17 @@ const schema = {
         },
         constraints: {
             type: 'array',
-            items: constraint_schema_1.constraintSchema,
+            items: {
+                $ref: '#/components/schemas/constraintSchema',
+            },
         },
-        parameters: parameters_schema_1.parametersSchema,
+        parameters: {
+            $ref: '#/components/schemas/parametersSchema',
+        },
+    },
+    'components/schemas': {
+        constraintSchema: constraint_schema_1.constraintSchema,
+        parametersSchema: parameters_schema_1.parametersSchema,
     },
 };
 exports.createStrategySchema = (0, types_1.createSchemaObject)(schema);

package/dist/lib/openapi/spec/create-strategy-schema.js.map

@@ -1 +1 @@
-{"version":3,"file":"create-strategy-schema.js","sourceRoot":"","sources":["../../../../src/lib/openapi/spec/create-strategy-schema.ts"],"names":[],"mappings":";;;AAAA,oCAAgE;AAChE,2DAAuD;AACvD,2DAAuD;AAEvD,MAAM,MAAM,GAAG;IACX,IAAI,EAAE,QAAQ;IACd,oBAAoB,EAAE,KAAK;IAC3B,UAAU,EAAE;QACR,IAAI,EAAE;YACF,IAAI,EAAE,QAAQ;SACjB;QACD,SAAS,EAAE;YACP,IAAI,EAAE,QAAQ;SACjB;QACD,WAAW,EAAE;YACT,IAAI,EAAE,OAAO;YACb,KAAK,EAAE,oCAAgB;SAC1B;QACD,UAAU,EAAE,oCAAgB;KAC/B;CACK,CAAC;AAIE,QAAA,oBAAoB,GAAG,IAAA,0BAAkB,EAAC,MAAM,CAAC,CAAC"}
+{"version":3,"file":"create-strategy-schema.js","sourceRoot":"","sources":["../../../../src/lib/openapi/spec/create-strategy-schema.ts"],"names":[],"mappings":";;;AAAA,oCAAgE;AAChE,2DAAuD;AACvD,2DAAuD;AAEvD,MAAM,MAAM,GAAG;IACX,IAAI,EAAE,QAAQ;IACd,oBAAoB,EAAE,KAAK;IAC3B,QAAQ,EAAE,CAAC,MAAM,CAAC;IAClB,UAAU,EAAE;QACR,IAAI,EAAE;YACF,IAAI,EAAE,QAAQ;SACjB;QACD,SAAS,EAAE;YACP,IAAI,EAAE,QAAQ;SACjB;QACD,WAAW,EAAE;YACT,IAAI,EAAE,OAAO;YACb,KAAK,EAAE;gBACH,IAAI,EAAE,uCAAuC;aAChD;SACJ;QACD,UAAU,EAAE;YACR,IAAI,EAAE,uCAAuC;SAChD;KACJ;IACD,oBAAoB,EAAE;QAClB,gBAAgB,EAAhB,oCAAgB;QAChB,gBAAgB,EAAhB,oCAAgB;KACnB;CACK,CAAC;AAIE,QAAA,oBAAoB,GAAG,IAAA,0BAAkB,EAAC,MAAM,CAAC,CAAC"}

package/dist/lib/openapi/spec/create-tag-request.d.ts

@@ -0,0 +1,2 @@
+import { OpenAPIV3 } from 'openapi-types';
+export declare const createTagRequest: OpenAPIV3.RequestBodyObject;

package/dist/lib/openapi/spec/create-tag-request.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTagRequest = void 0;
+exports.createTagRequest = {
+    required: true,
+    content: {
+        'application/json': {
+            schema: {
+                $ref: '#/components/schemas/tagSchema',
+            },
+        },
+    },
+};
+//# sourceMappingURL=create-tag-request.js.map

package/dist/lib/openapi/spec/create-tag-request.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-tag-request.js","sourceRoot":"","sources":["../../../../src/lib/openapi/spec/create-tag-request.ts"],"names":[],"mappings":";;;AAEa,QAAA,gBAAgB,GAAgC;IACzD,QAAQ,EAAE,IAAI;IACd,OAAO,EAAE;QACL,kBAAkB,EAAE;YAChB,MAAM,EAAE;gBACJ,IAAI,EAAE,gCAAgC;aACzC;SACJ;KACJ;CACJ,CAAC"}

package/dist/lib/openapi/spec/empty-response-schema.d.ts

@@ -0,0 +1,13 @@
+import { CreateSchemaType } from '../types';
+declare const schema: {
+    readonly type: "object";
+    readonly description: "OK";
+    readonly 'components/schemas': {};
+};
+export declare type EmptyResponseSchema = CreateSchemaType<typeof schema>;
+export declare const emptyResponseSchema: import("../../types/mutable").DeepMutable<Omit<{
+    readonly type: "object";
+    readonly description: "OK";
+    readonly 'components/schemas': {};
+}, "components/schemas">>;
+export {};

package/dist/lib/openapi/spec/empty-response-schema.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emptyResponseSchema = void 0;
+const types_1 = require("../types");
+const schema = {
+    type: 'object',
+    description: 'OK',
+    'components/schemas': {},
+};
+exports.emptyResponseSchema = (0, types_1.createSchemaObject)(schema);
+//# sourceMappingURL=empty-response-schema.js.map

package/dist/lib/openapi/spec/empty-response-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"empty-response-schema.js","sourceRoot":"","sources":["../../../../src/lib/openapi/spec/empty-response-schema.ts"],"names":[],"mappings":";;;AAAA,oCAAgE;AAEhE,MAAM,MAAM,GAAG;IACX,IAAI,EAAE,QAAQ;IACd,WAAW,EAAE,IAAI;IACjB,oBAAoB,EAAE,EAAE;CAClB,CAAC;AAIE,QAAA,mBAAmB,GAAG,IAAA,0BAAkB,EAAC,MAAM,CAAC,CAAC"}

package/dist/lib/openapi/spec/empty-response.d.ts

@@ -0,0 +1,2 @@
+import { OpenAPIV3 } from 'openapi-types';
+export declare const emptyResponse: OpenAPIV3.ResponseObject;

package/dist/lib/openapi/spec/empty-response.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emptyResponse = void 0;
+exports.emptyResponse = {
+    description: 'emptyResponse',
+    content: {
+        'application/json': {
+            schema: {
+                $ref: '#/components/schemas/emptyResponseSchema',
+            },
+        },
+    },
+};
+//# sourceMappingURL=empty-response.js.map

package/dist/lib/openapi/spec/empty-response.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"empty-response.js","sourceRoot":"","sources":["../../../../src/lib/openapi/spec/empty-response.ts"],"names":[],"mappings":";;;AAEa,QAAA,aAAa,GAA6B;IACnD,WAAW,EAAE,eAAe;IAC5B,OAAO,EAAE;QACL,kBAAkB,EAAE;YAChB,MAAM,EAAE;gBACJ,IAAI,EAAE,0CAA0C;aACnD;SACJ;KACJ;CACJ,CAAC"}

package/dist/lib/openapi/spec/feature-environment-response.d.ts

@@ -0,0 +1,2 @@
+import { OpenAPIV3 } from 'openapi-types';
+export declare const featureEnvironmentResponse: OpenAPIV3.ResponseObject;

package/dist/lib/openapi/spec/feature-environment-response.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.featureEnvironmentResponse = void 0;
+exports.featureEnvironmentResponse = {
+    description: 'featureEnvironmentResponse',
+    content: {
+        'application/json': {
+            schema: {
+                $ref: '#/components/schemas/featureEnvironmentSchema',
+            },
+        },
+    },
+};
+//# sourceMappingURL=feature-environment-response.js.map

package/dist/lib/openapi/spec/feature-environment-response.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-environment-response.js","sourceRoot":"","sources":["../../../../src/lib/openapi/spec/feature-environment-response.ts"],"names":[],"mappings":";;;AAEa,QAAA,0BAA0B,GAA6B;IAChE,WAAW,EAAE,4BAA4B;IACzC,OAAO,EAAE;QACL,kBAAkB,EAAE;YAChB,MAAM,EAAE;gBACJ,IAAI,EAAE,+CAA+C;aACxD;SACJ;KACJ;CACJ,CAAC"}

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

@@ -0,0 +1,293 @@
+import { CreateSchemaType } from '../types';
+declare let schema: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["name", "enabled"];
+    readonly properties: {
+        readonly name: {
+            readonly type: "string";
+        };
+        readonly environment: {
+            readonly type: "string";
+        };
+        readonly type: {
+            readonly type: "string";
+        };
+        readonly enabled: {
+            readonly type: "boolean";
+        };
+        readonly strategies: {
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/components/schemas/featureStrategySchema";
+            };
+        };
+    };
+    readonly 'components/schemas': {
+        readonly featureStrategySchema: import("../../types/mutable").DeepMutable<Omit<{
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["id", "featureName", "strategyName", "constraints", "parameters", "environment"];
+            readonly properties: {
+                readonly id: {
+                    readonly type: "string";
+                };
+                readonly name: {
+                    readonly type: "string";
+                };
+                readonly createdAt: {
+                    readonly type: "string";
+                    readonly format: "date";
+                    readonly nullable: true;
+                };
+                readonly featureName: {
+                    readonly type: "string";
+                };
+                readonly projectId: {
+                    readonly type: "string";
+                };
+                readonly environment: {
+                    readonly type: "string";
+                };
+                readonly strategyName: {
+                    readonly type: "string";
+                };
+                readonly sortOrder: {
+                    readonly type: "number";
+                };
+                readonly constraints: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/components/schemas/constraintSchema";
+                    };
+                };
+                readonly parameters: {
+                    readonly $ref: "#/components/schemas/parametersSchema";
+                };
+            };
+            readonly 'components/schemas': {
+                readonly constraintSchema: import("../../types/mutable").DeepMutable<Omit<{
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["contextName", "operator"];
+                    readonly properties: {
+                        readonly contextName: {
+                            readonly type: "string";
+                        };
+                        readonly operator: {
+                            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 type: "boolean";
+                        };
+                        readonly inverted: {
+                            readonly type: "boolean";
+                        };
+                        readonly values: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly value: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly 'components/schemas': {};
+                }, "components/schemas">>;
+                readonly parametersSchema: import("../../types/mutable").DeepMutable<Omit<{
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "string";
+                    };
+                    readonly 'components/schemas': {};
+                }, "components/schemas">>;
+            };
+        }, "components/schemas">>;
+        readonly constraintSchema: import("../../types/mutable").DeepMutable<Omit<{
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["contextName", "operator"];
+            readonly properties: {
+                readonly contextName: {
+                    readonly type: "string";
+                };
+                readonly operator: {
+                    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 type: "boolean";
+                };
+                readonly inverted: {
+                    readonly type: "boolean";
+                };
+                readonly values: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+                readonly value: {
+                    readonly type: "string";
+                };
+            };
+            readonly 'components/schemas': {};
+        }, "components/schemas">>;
+        readonly parametersSchema: import("../../types/mutable").DeepMutable<Omit<{
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly type: "string";
+            };
+            readonly 'components/schemas': {};
+        }, "components/schemas">>;
+    };
+};
+export declare type FeatureEnvironmentSchema = CreateSchemaType<typeof schema>;
+export declare const featureEnvironmentSchema: import("../../types/mutable").DeepMutable<Omit<{
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["name", "enabled"];
+    readonly properties: {
+        readonly name: {
+            readonly type: "string";
+        };
+        readonly environment: {
+            readonly type: "string";
+        };
+        readonly type: {
+            readonly type: "string";
+        };
+        readonly enabled: {
+            readonly type: "boolean";
+        };
+        readonly strategies: {
+            readonly type: "array";
+            readonly items: {
+                readonly $ref: "#/components/schemas/featureStrategySchema";
+            };
+        };
+    };
+    readonly 'components/schemas': {
+        readonly featureStrategySchema: import("../../types/mutable").DeepMutable<Omit<{
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["id", "featureName", "strategyName", "constraints", "parameters", "environment"];
+            readonly properties: {
+                readonly id: {
+                    readonly type: "string";
+                };
+                readonly name: {
+                    readonly type: "string";
+                };
+                readonly createdAt: {
+                    readonly type: "string";
+                    readonly format: "date";
+                    readonly nullable: true;
+                };
+                readonly featureName: {
+                    readonly type: "string";
+                };
+                readonly projectId: {
+                    readonly type: "string";
+                };
+                readonly environment: {
+                    readonly type: "string";
+                };
+                readonly strategyName: {
+                    readonly type: "string";
+                };
+                readonly sortOrder: {
+                    readonly type: "number";
+                };
+                readonly constraints: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/components/schemas/constraintSchema";
+                    };
+                };
+                readonly parameters: {
+                    readonly $ref: "#/components/schemas/parametersSchema";
+                };
+            };
+            readonly 'components/schemas': {
+                readonly constraintSchema: import("../../types/mutable").DeepMutable<Omit<{
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["contextName", "operator"];
+                    readonly properties: {
+                        readonly contextName: {
+                            readonly type: "string";
+                        };
+                        readonly operator: {
+                            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 type: "boolean";
+                        };
+                        readonly inverted: {
+                            readonly type: "boolean";
+                        };
+                        readonly values: {
+                            readonly type: "array";
+                            readonly items: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly value: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly 'components/schemas': {};
+                }, "components/schemas">>;
+                readonly parametersSchema: import("../../types/mutable").DeepMutable<Omit<{
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "string";
+                    };
+                    readonly 'components/schemas': {};
+                }, "components/schemas">>;
+            };
+        }, "components/schemas">>;
+        readonly constraintSchema: import("../../types/mutable").DeepMutable<Omit<{
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["contextName", "operator"];
+            readonly properties: {
+                readonly contextName: {
+                    readonly type: "string";
+                };
+                readonly operator: {
+                    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 type: "boolean";
+                };
+                readonly inverted: {
+                    readonly type: "boolean";
+                };
+                readonly values: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+                readonly value: {
+                    readonly type: "string";
+                };
+            };
+            readonly 'components/schemas': {};
+        }, "components/schemas">>;
+        readonly parametersSchema: import("../../types/mutable").DeepMutable<Omit<{
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly type: "string";
+            };
+            readonly 'components/schemas': {};
+        }, "components/schemas">>;
+    };
+}, "components/schemas">>;
+export {};

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.featureEnvironmentSchema = void 0;
+const types_1 = require("../types");
+const feature_strategy_schema_1 = require("./feature-strategy-schema");
+const constraint_schema_1 = require("./constraint-schema");
+const parameters_schema_1 = require("./parameters-schema");
+let schema = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['name', 'enabled'],
+    properties: {
+        name: {
+            type: 'string',
+        },
+        environment: {
+            type: 'string',
+        },
+        type: {
+            type: 'string',
+        },
+        enabled: {
+            type: 'boolean',
+        },
+        strategies: {
+            type: 'array',
+            items: {
+                $ref: '#/components/schemas/featureStrategySchema',
+            },
+        },
+    },
+    'components/schemas': {
+        featureStrategySchema: feature_strategy_schema_1.featureStrategySchema,
+        constraintSchema: constraint_schema_1.constraintSchema,
+        parametersSchema: parameters_schema_1.parametersSchema,
+    },
+};
+exports.featureEnvironmentSchema = (0, types_1.createSchemaObject)(schema);
+//# sourceMappingURL=feature-environment-schema.js.map