You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
* Determines whether the parameter value SHOULD allow reserved characters, as defined by RFC3986 `:/?#[]@!$&'()*+,;=` to be included without percent-encoding. The default value is `false`. This property SHALL be ignored if the request body media type is not `application/x-www-form-urlencoded` or `multipart/form-data`. If a value is explicitly defined, then the value of `contentType` (implicit or explicit) SHALL be ignored.
* The `$comment` {@link https://json-schema.org/learn/glossary#keyword keyword} is strictly intended for adding comments to a schema. Its value must always be a string. Unlike the annotations `title`, `description`, and `examples`, JSON schema {@link https://json-schema.org/learn/glossary#implementation implementations} aren't allowed to attach any meaning or behavior to it whatsoever, and may even strip them at any time. Therefore, they are useful for leaving notes to future editors of a JSON schema, but should not be used to communicate to users of the schema.
* {@link https://json-schema.org/understanding-json-schema/reference/combining#allof allOf} can not be used to "extend" a schema to add more details to it in the sense of object-oriented inheritance. {@link https://json-schema.org/learn/glossary#instance Instances} must independently be valid against "all of" the schemas in the `allOf`. See the section on {@link https://json-schema.org/understanding-json-schema/reference/object#extending Extending Closed Schemas} for more information.
21
22
*/
22
-
allOf?: Array<Document>;
23
+
allOf?: Array<TDocument>;
23
24
/**
24
25
* `anyOf`: (OR) Must be valid against _any_ of the subschemas
25
26
*
26
27
* To validate against `anyOf`, the given data must be valid against any (one or more) of the given subschemas.
27
28
*/
28
-
anyOf?: Array<Document>;
29
+
anyOf?: Array<TDocument>;
29
30
/**
30
31
* The `const` keyword is used to restrict a value to a single value.
* The `dependentSchemas` keyword conditionally applies a {@link https://json-schema.org/learn/glossary#subschema subschema} when a given property is present. This schema is applied in the same way {@link https://json-schema.org/understanding-json-schema/reference/combining#allof allOf} applies schemas. Nothing is merged or extended. Both schemas apply independently.
57
58
*/
58
-
dependentSchemas?: Record<string,Document>;
59
+
dependentSchemas?: Record<string,TDocument>;
59
60
/**
60
61
* The `deprecated` keyword is a boolean that indicates that the {@link https://json-schema.org/learn/glossary#instance instance} value the keyword applies to should not be used and may be removed in the future.
* If `then` and/or `else` appear in a schema without `if`, `then` and `else` are ignored.
75
76
*/
76
-
else?: Document;
77
+
else?: TDocument;
77
78
/**
78
79
* The `enum` {@link https://json-schema.org/learn/glossary#keyword keyword} is used to restrict a value to a fixed set of values. It must be an array with at least one element, where each element is unique.
* If `then` and/or `else` appear in a schema without `if`, `then` and `else` are ignored.
103
104
*/
104
-
if?: Document;
105
+
if?: TDocument;
105
106
/**
106
107
* `not`: (NOT) Must _not_ be valid against the given schema
107
108
*
108
109
* The `not` keyword declares that an instance validates if it doesn't validate against the given subschema.
109
110
*/
110
-
not?: Document;
111
+
not?: TDocument;
111
112
/**
112
113
* `oneOf`: (XOR) Must be valid against _exactly one_ of the subschemas
113
114
*
114
115
* To validate against `oneOf`, the given data must be valid against exactly one of the given subschemas.
115
116
*
116
117
* Careful consideration should be taken when using `oneOf` entries as the nature of it requires verification of _every_ sub-schema which can lead to increased processing times. Prefer `anyOf` where possible.
117
118
*/
118
-
oneOf?: Array<Document>;
119
+
oneOf?: Array<TDocument>;
119
120
/**
120
121
* The boolean keywords `readOnly` and `writeOnly` are typically used in an API context. `readOnly` indicates that a value should not be modified. It could be used to indicate that a `PUT` request that changes a value would result in a `400 Bad Request` response. `writeOnly` indicates that a value may be set, but will remain hidden. In could be used to indicate you can set a value with a `PUT` request, but it would not be included when retrieving that record with a `GET` request.
* If `then` and/or `else` appear in a schema without `if`, `then` and `else` are ignored.
131
132
*/
132
-
then?: Document;
133
+
then?: TDocument;
133
134
/**
134
135
* The `title` and `description` keywords must be strings. A "title" will preferably be short, whereas a "description" will provide a more lengthy explanation about the purpose of the data described by the schema.
* While the `items` schema must be valid for every item in the array, the `contains` schema only needs to validate against one or more items in the array.
150
153
*/
151
-
contains?: Document;
154
+
contains?: TDocument;
152
155
/**
153
156
* List validation is useful for arrays of arbitrary length where each item matches the same schema. For this kind of array, set the `items` {@link https://json-schema.org/learn/glossary#keyword keyword} to a single schema that will be used to validate all of the items in the array.
154
157
*
155
158
* The `items` keyword can be used to control whether it's valid to have additional items in a tuple beyond what is defined in `prefixItems`. The value of the `items` keyword is a schema that all additional items must pass in order for the keyword to validate.
156
159
*
157
160
* Note that `items` doesn't "see inside" any {@link https://json-schema.org/learn/glossary#instance instances} of `allOf`, `anyOf`, or `oneOf` in the same {@link https://json-schema.org/learn/glossary#subschema subschema}.
158
161
*/
159
-
items?: Document|false;
162
+
items?: TDocument|false;
160
163
/**
161
164
* `minContains` and `maxContains` can be used with `contains` to further specify how many times a schema matches a `contains` constraint. These keywords can be any non-negative number including zero.
* `prefixItems` is an array, where each item is a schema that corresponds to each index of the document's array. That is, an array where the first element validates the first element of the input array, the second element validates the second element of the input array, etc.
178
181
*/
179
-
prefixItems?: Array<Document>;
182
+
prefixItems?: Array<TDocument>;
180
183
/**
181
184
* The `unevaluatedItems` keyword is useful mainly when you want to add or disallow extra items to an array.
* The `additionalProperties` keyword is used to control the handling of extra stuff, that is, properties whose names are not listed in the `properties` keyword or match any of the regular expressions in the `patternProperties` keyword. By default any additional properties are allowed.
266
269
*
267
270
* The value of the `additionalProperties` keyword is a schema that will be used to validate any properties in the {@link https://json-schema.org/learn/glossary#instance instance} that are not matched by `properties` or `patternProperties`. Setting the `additionalProperties` schema to `false` means no additional properties will be allowed.
268
271
*
269
272
* It's important to note that `additionalProperties` only recognizes properties declared in the same {@link https://json-schema.org/learn/glossary#subschema subschema} as itself. So, `additionalProperties` can restrict you from "extending" a schema using {@link https://json-schema.org/understanding-json-schema/reference/combining combining} keywords such as {@link https://json-schema.org/understanding-json-schema/reference/combining#allof allOf}.
270
273
*/
271
-
additionalProperties?: Document|false;
274
+
additionalProperties?: TDocument|false;
272
275
/**
273
276
* The number of properties on an object can be restricted using the `minProperties` and `maxProperties` keywords. Each of these must be a non-negative integer.
* Sometimes you want to say that, given a particular kind of property name, the value should match a particular schema. That's where `patternProperties` comes in: it maps regular expressions to schemas. If a property name matches the given regular expression, the property value must validate against the corresponding schema.
282
285
*/
283
-
patternProperties?: Record<string,Document>;
286
+
patternProperties?: Record<string,TDocument>;
284
287
/**
285
288
* The properties (key-value pairs) on an object are defined using the `properties` {@link https://json-schema.org/learn/glossary#keyword keyword}. The value of `properties` is an object, where each key is the name of a property and each value is a {@link https://json-schema.org/learn/glossary#schema schema} used to validate that property. Any property that doesn't match any of the property names in the `properties` keyword is ignored by this keyword.
286
289
*/
287
-
properties?: Record<string,Document|true>;
290
+
properties?: Record<string,TDocument|true>;
288
291
/**
289
292
* The names of properties can be validated against a schema, irrespective of their values. This can be useful if you don't want to enforce specific properties, but you want to make sure that the names of those properties follow a specific convention. You might, for example, want to enforce that all names are valid ASCII tokens so they can be used as attributes in a particular programming language.
* By default, the properties defined by the `properties` keyword are not required. However, one can provide a list of required properties using the `required` keyword.
* `unevaluatedProperties` works by collecting any properties that are successfully validated when processing the schemas and using those as the allowed list of properties. This allows you to do more complex things like conditionally adding properties.
* This object MAY be extended with {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#specification-extensions Specification Extensions}, though as noted, additional properties MAY omit the `x-` prefix within this object.
1670
1670
*/
1671
-
exporttypeSchemaObject=JSONSchemaDraft2020_12&
1672
-
OpenAPIV3_1SchemaExtensions&
1673
-
SpecExtensions&
1674
-
EnumExtensions;
1671
+
exportinterfaceSchemaObject
1672
+
extends
1673
+
JSONSchemaDraft2020_12<SchemaObject>,
1674
+
OpenAPIV3_1SchemaExtensions,
1675
+
SpecExtensions,
1676
+
EnumExtensions{}
1675
1677
1676
1678
/**
1677
1679
* Lists the required security schemes to execute this operation. The name used for each property MUST correspond to a security scheme declared in the {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#componentsSecuritySchemes Security Schemes} under the {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#components-object Components Object}.
0 commit comments