fork of hey-api/openapi-ts because I need some additional things
test: update snapshots
+1326
-1284
+1
-1
examples/openapi-ts-nuxt/package.json
+1
-1
examples/openapi-ts-nuxt/package.json
+1
-1
examples/openapi-ts-sample/package.json
+1
-1
examples/openapi-ts-sample/package.json
+4
-2
examples/openapi-ts-sample/src/client/client/client.ts
+4
-2
examples/openapi-ts-sample/src/client/client/client.ts
···
143
143
};
144
144
}
145
145
146
-
let error = await response.text();
146
+
const textError = await response.text();
147
+
let jsonError: unknown;
147
148
148
149
try {
149
-
error = JSON.parse(error);
150
+
jsonError = JSON.parse(textError);
150
151
} catch {
151
152
// noop
152
153
}
153
154
155
+
const error = jsonError ?? textError;
154
156
let finalError = error;
155
157
156
158
for (const fn of interceptors.error._fns) {
+9
-5
examples/openapi-ts-sample/src/client/core/bodySerializer.ts
+9
-5
examples/openapi-ts-sample/src/client/core/bodySerializer.ts
···
14
14
object?: SerializerOptions<ObjectStyle>;
15
15
}
16
16
17
-
const serializeFormDataPair = (data: FormData, key: string, value: unknown) => {
17
+
const serializeFormDataPair = (
18
+
data: FormData,
19
+
key: string,
20
+
value: unknown,
21
+
): void => {
18
22
if (typeof value === 'string' || value instanceof Blob) {
19
23
data.append(key, value);
20
24
} else {
···
26
30
data: URLSearchParams,
27
31
key: string,
28
32
value: unknown,
29
-
) => {
33
+
): void => {
30
34
if (typeof value === 'string') {
31
35
data.append(key, value);
32
36
} else {
···
37
41
export const formDataBodySerializer = {
38
42
bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(
39
43
body: T,
40
-
) => {
44
+
): FormData => {
41
45
const data = new FormData();
42
46
43
47
Object.entries(body).forEach(([key, value]) => {
···
56
60
};
57
61
58
62
export const jsonBodySerializer = {
59
-
bodySerializer: <T>(body: T) =>
63
+
bodySerializer: <T>(body: T): string =>
60
64
JSON.stringify(body, (_key, value) =>
61
65
typeof value === 'bigint' ? value.toString() : value,
62
66
),
···
65
69
export const urlSearchParamsBodySerializer = {
66
70
bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(
67
71
body: T,
68
-
) => {
72
+
): string => {
69
73
const data = new URLSearchParams();
70
74
71
75
Object.entries(body).forEach(([key, value]) => {
+10
examples/openapi-ts-sample/src/client/core/params.ts
+10
examples/openapi-ts-sample/src/client/core/params.ts
···
3
3
export type Field =
4
4
| {
5
5
in: Exclude<Slot, 'body'>;
6
+
/**
7
+
* Field name. This is the name we want the user to see and use.
8
+
*/
6
9
key: string;
10
+
/**
11
+
* Field mapped name. This is the name we want to use in the request.
12
+
* If omitted, we use the same value as `key`.
13
+
*/
7
14
map?: string;
8
15
}
9
16
| {
10
17
in: Extract<Slot, 'body'>;
18
+
/**
19
+
* Key isn't required for bodies.
20
+
*/
11
21
key?: string;
12
22
map?: string;
13
23
};
+14
examples/openapi-ts-sample/src/client/core/types.ts
+14
examples/openapi-ts-sample/src/client/core/types.ts
···
102
102
*/
103
103
responseValidator?: (data: unknown) => Promise<unknown>;
104
104
}
105
+
106
+
type IsExactlyNeverOrNeverUndefined<T> = [T] extends [never]
107
+
? true
108
+
: [T] extends [never | undefined]
109
+
? [undefined] extends [T]
110
+
? false
111
+
: true
112
+
: false;
113
+
114
+
export type OmitNever<T extends Record<string, unknown>> = {
115
+
[K in keyof T as IsExactlyNeverOrNeverUndefined<T[K]> extends true
116
+
? never
117
+
: K]: T[K];
118
+
};
+98
-98
examples/openapi-ts-sample/src/client/zod.gen.ts
+98
-98
examples/openapi-ts-sample/src/client/zod.gen.ts
···
3
3
import { z } from 'zod';
4
4
5
5
export const zOrder = z.object({
6
-
complete: z.boolean().optional(),
7
-
id: z.coerce.bigint().optional(),
8
-
petId: z.coerce.bigint().optional(),
9
-
quantity: z.number().int().optional(),
10
-
shipDate: z.string().datetime().optional(),
11
-
status: z.enum(['placed', 'approved', 'delivered']).optional(),
6
+
complete: z.optional(z.boolean()),
7
+
id: z.optional(z.coerce.bigint()),
8
+
petId: z.optional(z.coerce.bigint()),
9
+
quantity: z.optional(z.int()),
10
+
shipDate: z.optional(z.iso.datetime()),
11
+
status: z.optional(z.enum(['placed', 'approved', 'delivered'])),
12
12
});
13
13
14
14
export const zCategory = z.object({
15
-
id: z.coerce.bigint().optional(),
16
-
name: z.string().optional(),
15
+
id: z.optional(z.coerce.bigint()),
16
+
name: z.optional(z.string()),
17
17
});
18
18
19
19
export const zUser = z.object({
20
-
email: z.string().optional(),
21
-
firstName: z.string().optional(),
22
-
id: z.coerce.bigint().optional(),
23
-
lastName: z.string().optional(),
24
-
password: z.string().optional(),
25
-
phone: z.string().optional(),
26
-
userStatus: z.number().int().optional(),
27
-
username: z.string().optional(),
20
+
email: z.optional(z.string()),
21
+
firstName: z.optional(z.string()),
22
+
id: z.optional(z.coerce.bigint()),
23
+
lastName: z.optional(z.string()),
24
+
password: z.optional(z.string()),
25
+
phone: z.optional(z.string()),
26
+
userStatus: z.optional(z.int()),
27
+
username: z.optional(z.string()),
28
28
});
29
29
30
30
export const zTag = z.object({
31
-
id: z.coerce.bigint().optional(),
32
-
name: z.string().optional(),
31
+
id: z.optional(z.coerce.bigint()),
32
+
name: z.optional(z.string()),
33
33
});
34
34
35
35
export const zPet = z.object({
36
-
category: zCategory.optional(),
37
-
id: z.coerce.bigint().optional(),
36
+
category: z.optional(zCategory),
37
+
id: z.optional(z.coerce.bigint()),
38
38
name: z.string(),
39
39
photoUrls: z.array(z.string()),
40
-
status: z.enum(['available', 'pending', 'sold']).optional(),
41
-
tags: z.array(zTag).optional(),
40
+
status: z.optional(z.enum(['available', 'pending', 'sold'])),
41
+
tags: z.optional(z.array(zTag)),
42
42
});
43
43
44
44
export const zApiResponse = z.object({
45
-
code: z.number().int().optional(),
46
-
message: z.string().optional(),
47
-
type: z.string().optional(),
45
+
code: z.optional(z.int()),
46
+
message: z.optional(z.string()),
47
+
type: z.optional(z.string()),
48
48
});
49
49
50
50
export const zPet2 = zPet;
···
56
56
57
57
export const zAddPetData = z.object({
58
58
body: zPet,
59
-
path: z.never().optional(),
60
-
query: z.never().optional(),
59
+
path: z.optional(z.never()),
60
+
query: z.optional(z.never()),
61
61
});
62
62
63
63
/**
···
67
67
68
68
export const zUpdatePetData = z.object({
69
69
body: zPet,
70
-
path: z.never().optional(),
71
-
query: z.never().optional(),
70
+
path: z.optional(z.never()),
71
+
query: z.optional(z.never()),
72
72
});
73
73
74
74
/**
···
77
77
export const zUpdatePetResponse = zPet;
78
78
79
79
export const zFindPetsByStatusData = z.object({
80
-
body: z.never().optional(),
81
-
path: z.never().optional(),
82
-
query: z
83
-
.object({
84
-
status: z.enum(['available', 'pending', 'sold']).optional(),
85
-
})
86
-
.optional(),
80
+
body: z.optional(z.never()),
81
+
path: z.optional(z.never()),
82
+
query: z.optional(
83
+
z.object({
84
+
status: z.optional(z.enum(['available', 'pending', 'sold'])),
85
+
}),
86
+
),
87
87
});
88
88
89
89
/**
···
92
92
export const zFindPetsByStatusResponse = z.array(zPet);
93
93
94
94
export const zFindPetsByTagsData = z.object({
95
-
body: z.never().optional(),
96
-
path: z.never().optional(),
97
-
query: z
98
-
.object({
99
-
tags: z.array(z.string()).optional(),
100
-
})
101
-
.optional(),
95
+
body: z.optional(z.never()),
96
+
path: z.optional(z.never()),
97
+
query: z.optional(
98
+
z.object({
99
+
tags: z.optional(z.array(z.string())),
100
+
}),
101
+
),
102
102
});
103
103
104
104
/**
···
107
107
export const zFindPetsByTagsResponse = z.array(zPet);
108
108
109
109
export const zDeletePetData = z.object({
110
-
body: z.never().optional(),
111
-
headers: z
112
-
.object({
113
-
api_key: z.string().optional(),
114
-
})
115
-
.optional(),
110
+
body: z.optional(z.never()),
111
+
headers: z.optional(
112
+
z.object({
113
+
api_key: z.optional(z.string()),
114
+
}),
115
+
),
116
116
path: z.object({
117
117
petId: z.coerce.bigint(),
118
118
}),
119
-
query: z.never().optional(),
119
+
query: z.optional(z.never()),
120
120
});
121
121
122
122
export const zGetPetByIdData = z.object({
123
-
body: z.never().optional(),
123
+
body: z.optional(z.never()),
124
124
path: z.object({
125
125
petId: z.coerce.bigint(),
126
126
}),
127
-
query: z.never().optional(),
127
+
query: z.optional(z.never()),
128
128
});
129
129
130
130
/**
···
133
133
export const zGetPetByIdResponse = zPet;
134
134
135
135
export const zUpdatePetWithFormData = z.object({
136
-
body: z.never().optional(),
136
+
body: z.optional(z.never()),
137
137
path: z.object({
138
138
petId: z.coerce.bigint(),
139
139
}),
140
-
query: z
141
-
.object({
142
-
name: z.string().optional(),
143
-
status: z.string().optional(),
144
-
})
145
-
.optional(),
140
+
query: z.optional(
141
+
z.object({
142
+
name: z.optional(z.string()),
143
+
status: z.optional(z.string()),
144
+
}),
145
+
),
146
146
});
147
147
148
148
/**
···
151
151
export const zUpdatePetWithFormResponse = zPet;
152
152
153
153
export const zUploadFileData = z.object({
154
-
body: z.string().optional(),
154
+
body: z.optional(z.string()),
155
155
path: z.object({
156
156
petId: z.coerce.bigint(),
157
157
}),
158
-
query: z
159
-
.object({
160
-
additionalMetadata: z.string().optional(),
161
-
})
162
-
.optional(),
158
+
query: z.optional(
159
+
z.object({
160
+
additionalMetadata: z.optional(z.string()),
161
+
}),
162
+
),
163
163
});
164
164
165
165
/**
···
168
168
export const zUploadFileResponse = zApiResponse;
169
169
170
170
export const zGetInventoryData = z.object({
171
-
body: z.never().optional(),
172
-
path: z.never().optional(),
173
-
query: z.never().optional(),
171
+
body: z.optional(z.never()),
172
+
path: z.optional(z.never()),
173
+
query: z.optional(z.never()),
174
174
});
175
175
176
176
/**
···
179
179
export const zGetInventoryResponse = z.object({});
180
180
181
181
export const zPlaceOrderData = z.object({
182
-
body: zOrder.optional(),
183
-
path: z.never().optional(),
184
-
query: z.never().optional(),
182
+
body: z.optional(zOrder),
183
+
path: z.optional(z.never()),
184
+
query: z.optional(z.never()),
185
185
});
186
186
187
187
/**
···
190
190
export const zPlaceOrderResponse = zOrder;
191
191
192
192
export const zDeleteOrderData = z.object({
193
-
body: z.never().optional(),
193
+
body: z.optional(z.never()),
194
194
path: z.object({
195
195
orderId: z.coerce.bigint(),
196
196
}),
197
-
query: z.never().optional(),
197
+
query: z.optional(z.never()),
198
198
});
199
199
200
200
export const zGetOrderByIdData = z.object({
201
-
body: z.never().optional(),
201
+
body: z.optional(z.never()),
202
202
path: z.object({
203
203
orderId: z.coerce.bigint(),
204
204
}),
205
-
query: z.never().optional(),
205
+
query: z.optional(z.never()),
206
206
});
207
207
208
208
/**
···
211
211
export const zGetOrderByIdResponse = zOrder;
212
212
213
213
export const zCreateUserData = z.object({
214
-
body: zUser.optional(),
215
-
path: z.never().optional(),
216
-
query: z.never().optional(),
214
+
body: z.optional(zUser),
215
+
path: z.optional(z.never()),
216
+
query: z.optional(z.never()),
217
217
});
218
218
219
219
/**
···
222
222
export const zCreateUserResponse = zUser;
223
223
224
224
export const zCreateUsersWithListInputData = z.object({
225
-
body: z.array(zUser).optional(),
226
-
path: z.never().optional(),
227
-
query: z.never().optional(),
225
+
body: z.optional(z.array(zUser)),
226
+
path: z.optional(z.never()),
227
+
query: z.optional(z.never()),
228
228
});
229
229
230
230
/**
···
233
233
export const zCreateUsersWithListInputResponse = zUser;
234
234
235
235
export const zLoginUserData = z.object({
236
-
body: z.never().optional(),
237
-
path: z.never().optional(),
238
-
query: z
239
-
.object({
240
-
password: z.string().optional(),
241
-
username: z.string().optional(),
242
-
})
243
-
.optional(),
236
+
body: z.optional(z.never()),
237
+
path: z.optional(z.never()),
238
+
query: z.optional(
239
+
z.object({
240
+
password: z.optional(z.string()),
241
+
username: z.optional(z.string()),
242
+
}),
243
+
),
244
244
});
245
245
246
246
/**
···
249
249
export const zLoginUserResponse = z.string();
250
250
251
251
export const zLogoutUserData = z.object({
252
-
body: z.never().optional(),
253
-
path: z.never().optional(),
254
-
query: z.never().optional(),
252
+
body: z.optional(z.never()),
253
+
path: z.optional(z.never()),
254
+
query: z.optional(z.never()),
255
255
});
256
256
257
257
export const zDeleteUserData = z.object({
258
-
body: z.never().optional(),
258
+
body: z.optional(z.never()),
259
259
path: z.object({
260
260
username: z.string(),
261
261
}),
262
-
query: z.never().optional(),
262
+
query: z.optional(z.never()),
263
263
});
264
264
265
265
export const zGetUserByNameData = z.object({
266
-
body: z.never().optional(),
266
+
body: z.optional(z.never()),
267
267
path: z.object({
268
268
username: z.string(),
269
269
}),
270
-
query: z.never().optional(),
270
+
query: z.optional(z.never()),
271
271
});
272
272
273
273
/**
···
276
276
export const zGetUserByNameResponse = zUser;
277
277
278
278
export const zUpdateUserData = z.object({
279
-
body: zUser.optional(),
279
+
body: z.optional(zUser),
280
280
path: z.object({
281
281
username: z.string(),
282
282
}),
283
-
query: z.never().optional(),
283
+
query: z.optional(z.never()),
284
284
});
+1
-1
packages/openapi-ts-tests/package.json
+1
-1
packages/openapi-ts-tests/package.json
+5
-5
packages/openapi-ts-tests/test/__snapshots__/2.0.x/plugins/@hey-api/transformers/type-format-zod/zod.gen.ts
+5
-5
packages/openapi-ts-tests/test/__snapshots__/2.0.x/plugins/@hey-api/transformers/type-format-zod/zod.gen.ts
···
3
3
import { z } from 'zod';
4
4
5
5
export const zFoo = z.object({
6
-
bar: z.number().int().optional(),
6
+
bar: z.optional(z.int()),
7
7
foo: z.coerce.bigint().default(BigInt(0)),
8
8
id: z.string()
9
9
});
10
10
11
11
export const zBar = z.object({
12
-
foo: z.number().int()
12
+
foo: z.int()
13
13
});
14
14
15
15
export const zPostFooData = z.object({
16
-
body: z.never().optional(),
17
-
path: z.never().optional(),
18
-
query: z.never().optional()
16
+
body: z.optional(z.never()),
17
+
path: z.optional(z.never()),
18
+
query: z.optional(z.never())
19
19
});
20
20
21
21
/**
+208
-208
packages/openapi-ts-tests/test/__snapshots__/2.0.x/plugins/zod/default/zod.gen.ts
+208
-208
packages/openapi-ts-tests/test/__snapshots__/2.0.x/plugins/zod/default/zod.gen.ts
···
8
8
*
9
9
* Fourth line
10
10
*/
11
-
export const zCommentWithBreaks = z.number().int();
11
+
export const zCommentWithBreaks = z.int();
12
12
13
13
/**
14
14
* Testing backticks in string: `backticks` and ```multiple backticks``` should work
15
15
*/
16
-
export const zCommentWithBackticks = z.number().int();
16
+
export const zCommentWithBackticks = z.int();
17
17
18
18
/**
19
19
* Testing backticks and quotes in string: `backticks`, 'quotes', "double quotes" and ```multiple backticks``` should work
20
20
*/
21
-
export const zCommentWithBackticksAndQuotes = z.number().int();
21
+
export const zCommentWithBackticksAndQuotes = z.int();
22
22
23
23
/**
24
24
* Testing slashes in string: \backwards\\\ and /forwards/// should work
25
25
*/
26
-
export const zCommentWithSlashes = z.number().int();
26
+
export const zCommentWithSlashes = z.int();
27
27
28
28
/**
29
29
* Testing expression placeholders in string: ${expression} should work
30
30
*/
31
-
export const zCommentWithExpressionPlaceholders = z.number().int();
31
+
export const zCommentWithExpressionPlaceholders = z.int();
32
32
33
33
/**
34
34
* Testing quotes in string: 'single quote''' and "double quotes""" should work
35
35
*/
36
-
export const zCommentWithQuotes = z.number().int();
36
+
export const zCommentWithQuotes = z.int();
37
37
38
38
/**
39
39
* Testing reserved characters in string: * inline * and ** inline ** should work
40
40
*/
41
-
export const zCommentWithReservedCharacters = z.number().int();
41
+
export const zCommentWithReservedCharacters = z.int();
42
42
43
43
/**
44
44
* This is a simple number
45
45
*/
46
-
export const zSimpleInteger = z.number().int();
46
+
export const zSimpleInteger = z.int();
47
47
48
48
/**
49
49
* This is a simple boolean
···
69
69
* This is a model with one string property
70
70
*/
71
71
export const zModelWithString = z.object({
72
-
prop: z.string().optional()
72
+
prop: z.optional(z.string())
73
73
});
74
74
75
75
export const zSimpleReference = zModelWithString;
···
109
109
/**
110
110
* This is a simple array with numbers
111
111
*/
112
-
export const zArrayWithNumbers = z.array(z.number().int());
112
+
export const zArrayWithNumbers = z.array(z.int());
113
113
114
114
/**
115
115
* This is a simple array with booleans
···
135
135
* This is a simple array with properties
136
136
*/
137
137
export const zArrayWithProperties = z.array(z.object({
138
-
foo: z.string().optional(),
139
-
bar: z.string().optional()
138
+
foo: z.optional(z.string()),
139
+
bar: z.optional(z.string())
140
140
}));
141
141
142
142
/**
···
157
157
/**
158
158
* This is a string dictionary
159
159
*/
160
-
export const zDictionaryWithDictionary = z.record(z.object({}));
160
+
export const zDictionaryWithDictionary = z.record(z.string(), z.object({}));
161
161
162
162
/**
163
163
* This is a complex dictionary
164
164
*/
165
-
export const zDictionaryWithProperties = z.record(z.object({
166
-
foo: z.string().optional(),
167
-
bar: z.string().optional()
165
+
export const zDictionaryWithProperties = z.record(z.string(), z.object({
166
+
foo: z.optional(z.string()),
167
+
bar: z.optional(z.string())
168
168
}));
169
169
170
170
/**
···
176
176
* This is a model with one number property
177
177
*/
178
178
export const zModelWithInteger = z.object({
179
-
prop: z.number().int().optional()
179
+
prop: z.optional(z.int())
180
180
});
181
181
182
182
/**
183
183
* This is a model with one boolean property
184
184
*/
185
185
export const zModelWithBoolean = z.object({
186
-
prop: z.boolean().optional()
186
+
prop: z.optional(z.boolean())
187
187
});
188
188
189
189
/**
190
190
* This is a model with one string property
191
191
*/
192
192
export const zModelWithStringError = z.object({
193
-
prop: z.string().optional()
193
+
prop: z.optional(z.string())
194
194
});
195
195
196
196
/**
197
197
* This is a model with one string property
198
198
*/
199
199
export const zModelWithNullableString = z.object({
200
-
nullableProp: z.union([
200
+
nullableProp: z.optional(z.union([
201
201
z.string(),
202
202
z.null()
203
-
]).optional(),
203
+
])),
204
204
nullableRequiredProp: z.union([
205
205
z.string(),
206
206
z.null()
···
211
211
* This is a model with one enum
212
212
*/
213
213
export const zModelWithEnum = z.object({
214
-
test: z.enum([
214
+
test: z.optional(z.enum([
215
215
'Success',
216
216
'Warning',
217
217
'Error',
218
218
'ØÆÅ字符串'
219
-
]).optional(),
220
-
statusCode: z.enum([
219
+
])),
220
+
statusCode: z.optional(z.enum([
221
221
'100',
222
222
'200 FOO',
223
223
'300 FOO_BAR',
224
224
'400 foo-bar',
225
225
'500 foo.bar',
226
226
'600 foo&bar'
227
-
]).optional(),
228
-
bool: z.unknown().optional()
227
+
])),
228
+
bool: z.optional(z.unknown())
229
229
});
230
230
231
231
/**
232
232
* This is a model with one enum
233
233
*/
234
234
export const zModelWithEnumFromDescription = z.object({
235
-
test: z.number().int().optional()
235
+
test: z.optional(z.int())
236
236
});
237
237
238
238
/**
239
239
* This is a model with nested enums
240
240
*/
241
241
export const zModelWithNestedEnums = z.object({
242
-
dictionaryWithEnum: z.object({}).optional(),
243
-
dictionaryWithEnumFromDescription: z.object({}).optional(),
244
-
arrayWithEnum: z.array(z.enum([
242
+
dictionaryWithEnum: z.optional(z.object({})),
243
+
dictionaryWithEnumFromDescription: z.optional(z.object({})),
244
+
arrayWithEnum: z.optional(z.array(z.enum([
245
245
'Success',
246
246
'Warning',
247
247
'Error'
248
-
])).optional(),
249
-
arrayWithDescription: z.array(z.number().int()).optional()
248
+
]))),
249
+
arrayWithDescription: z.optional(z.array(z.int()))
250
250
});
251
251
252
252
/**
···
255
255
export const zModelWithProperties = z.object({
256
256
required: z.string(),
257
257
requiredAndReadOnly: z.string().readonly(),
258
-
string: z.string().optional(),
259
-
number: z.number().optional(),
260
-
boolean: z.boolean().optional(),
261
-
reference: zModelWithString.optional(),
262
-
'property with space': z.string().optional(),
263
-
default: z.string().optional(),
264
-
try: z.string().optional(),
265
-
'@namespace.string': z.string().readonly().optional(),
266
-
'@namespace.integer': z.number().int().readonly().optional()
258
+
string: z.optional(z.string()),
259
+
number: z.optional(z.number()),
260
+
boolean: z.optional(z.boolean()),
261
+
reference: z.optional(zModelWithString),
262
+
'property with space': z.optional(z.string()),
263
+
default: z.optional(z.string()),
264
+
try: z.optional(z.string()),
265
+
'@namespace.string': z.optional(z.string().readonly()),
266
+
'@namespace.integer': z.optional(z.int().readonly())
267
267
});
268
268
269
269
/**
270
270
* This is a model with one property containing a reference
271
271
*/
272
272
export const zModelWithReference = z.object({
273
-
prop: zModelWithProperties.optional()
273
+
prop: z.optional(zModelWithProperties)
274
274
});
275
275
276
276
/**
277
277
* This is a model with one property containing an array
278
278
*/
279
279
export const zModelWithArray = z.object({
280
-
prop: z.array(zModelWithString).optional(),
281
-
propWithFile: z.array(z.string()).optional(),
282
-
propWithNumber: z.array(z.number()).optional()
280
+
prop: z.optional(z.array(zModelWithString)),
281
+
propWithFile: z.optional(z.array(z.string())),
282
+
propWithNumber: z.optional(z.array(z.number()))
283
283
});
284
284
285
285
/**
286
286
* This is a model with one property containing a dictionary
287
287
*/
288
288
export const zModelWithDictionary = z.object({
289
-
prop: z.object({}).optional()
289
+
prop: z.optional(z.object({}))
290
290
});
291
291
292
292
/**
293
293
* This is a model with one property containing a circular reference
294
294
*/
295
-
export const zModelWithCircularReference: z.AnyZodObject = z.object({
296
-
prop: z.lazy(() => {
295
+
export const zModelWithCircularReference = z.object({
296
+
prop: z.optional(z.lazy(() => {
297
297
return zModelWithCircularReference;
298
-
}).optional()
298
+
}))
299
299
});
300
300
301
301
/**
···
313
313
* This is a model with duplicated properties
314
314
*/
315
315
export const zModelWithDuplicateProperties = z.object({
316
-
prop: zModelWithString.optional()
316
+
prop: z.optional(zModelWithString)
317
317
});
318
318
319
319
/**
320
320
* This is a model with ordered properties
321
321
*/
322
322
export const zModelWithOrderedProperties = z.object({
323
-
zebra: z.string().optional(),
324
-
apple: z.string().optional(),
325
-
hawaii: z.string().optional()
323
+
zebra: z.optional(z.string()),
324
+
apple: z.optional(z.string()),
325
+
hawaii: z.optional(z.string())
326
326
});
327
327
328
328
/**
329
329
* This is a model with duplicated imports
330
330
*/
331
331
export const zModelWithDuplicateImports = z.object({
332
-
propA: zModelWithString.optional(),
333
-
propB: zModelWithString.optional(),
334
-
propC: zModelWithString.optional()
332
+
propA: z.optional(zModelWithString),
333
+
propB: z.optional(zModelWithString),
334
+
propC: z.optional(zModelWithString)
335
335
});
336
336
337
337
/**
338
338
* This is a model that extends another model
339
339
*/
340
340
export const zModelThatExtends = zModelWithString.and(z.object({
341
-
propExtendsA: z.string().optional(),
342
-
propExtendsB: zModelWithString.optional()
341
+
propExtendsA: z.optional(z.string()),
342
+
propExtendsB: z.optional(zModelWithString)
343
343
}));
344
344
345
345
/**
346
346
* This is a model that extends another model
347
347
*/
348
348
export const zModelThatExtendsExtends = zModelWithString.and(zModelThatExtends).and(z.object({
349
-
propExtendsC: z.string().optional(),
350
-
propExtendsD: zModelWithString.optional()
349
+
propExtendsC: z.optional(z.string()),
350
+
propExtendsD: z.optional(zModelWithString)
351
351
}));
352
352
353
353
export const zDefault = z.object({
354
-
name: z.string().optional()
354
+
name: z.optional(z.string())
355
355
});
356
356
357
357
/**
···
360
360
export const zModelWithPattern = z.object({
361
361
key: z.string().max(64).regex(/^[a-zA-Z0-9_]*$/),
362
362
name: z.string().max(255),
363
-
enabled: z.boolean().readonly().optional(),
364
-
modified: z.string().datetime().readonly().optional(),
365
-
id: z.string().regex(/^\d{2}-\d{3}-\d{4}$/).optional(),
366
-
text: z.string().regex(/^\w+$/).optional(),
367
-
patternWithSingleQuotes: z.string().regex(/^[a-zA-Z0-9']*$/).optional(),
368
-
patternWithNewline: z.string().regex(/aaa\nbbb/).optional(),
369
-
patternWithBacktick: z.string().regex(/aaa`bbb/).optional()
363
+
enabled: z.optional(z.boolean().readonly()),
364
+
modified: z.optional(z.iso.datetime().readonly()),
365
+
id: z.optional(z.string().regex(/^\d{2}-\d{3}-\d{4}$/)),
366
+
text: z.optional(z.string().regex(/^\w+$/)),
367
+
patternWithSingleQuotes: z.optional(z.string().regex(/^[a-zA-Z0-9']*$/)),
368
+
patternWithNewline: z.optional(z.string().regex(/aaa\nbbb/)),
369
+
patternWithBacktick: z.optional(z.string().regex(/aaa`bbb/))
370
370
});
371
371
372
372
export const zParameterActivityParams = z.object({
373
-
description: z.string().optional(),
374
-
graduate_id: z.number().int().optional(),
375
-
organization_id: z.number().int().optional(),
376
-
parent_activity: z.number().int().optional(),
377
-
post_id: z.number().int().optional()
373
+
description: z.optional(z.string()),
374
+
graduate_id: z.optional(z.int()),
375
+
organization_id: z.optional(z.int()),
376
+
parent_activity: z.optional(z.int()),
377
+
post_id: z.optional(z.int())
378
378
});
379
379
380
380
export const zResponsePostActivityResponse = z.object({
381
-
description: z.string().optional(),
382
-
graduate_id: z.number().int().optional(),
383
-
organization_id: z.number().int().optional(),
384
-
parent_activity_id: z.number().int().optional(),
385
-
post_id: z.number().int().optional()
381
+
description: z.optional(z.string()),
382
+
graduate_id: z.optional(z.int()),
383
+
organization_id: z.optional(z.int()),
384
+
parent_activity_id: z.optional(z.int()),
385
+
post_id: z.optional(z.int())
386
386
});
387
387
388
388
export const zFailureFailure = z.object({
389
-
error: z.string().optional(),
390
-
message: z.string().optional(),
391
-
reference_code: z.string().optional()
389
+
error: z.optional(z.string()),
390
+
message: z.optional(z.string()),
391
+
reference_code: z.optional(z.string())
392
392
});
393
393
394
394
export const zServiceWithEmptyTagData = z.object({
395
-
body: z.never().optional(),
396
-
path: z.never().optional(),
397
-
query: z.never().optional()
395
+
body: z.optional(z.never()),
396
+
path: z.optional(z.never()),
397
+
query: z.optional(z.never())
398
398
});
399
399
400
400
export const zPatchApiVbyApiVersionNoTagData = z.object({
401
-
body: z.never().optional(),
402
-
path: z.never().optional(),
403
-
query: z.never().optional()
401
+
body: z.optional(z.never()),
402
+
path: z.optional(z.never()),
403
+
query: z.optional(z.never())
404
404
});
405
405
406
406
export const zFooWowData = z.object({
407
-
body: z.never().optional(),
408
-
path: z.never().optional(),
409
-
query: z.never().optional()
407
+
body: z.optional(z.never()),
408
+
path: z.optional(z.never()),
409
+
query: z.optional(z.never())
410
410
});
411
411
412
412
export const zDeleteCallWithoutParametersAndResponseData = z.object({
413
-
body: z.never().optional(),
414
-
path: z.never().optional(),
415
-
query: z.never().optional()
413
+
body: z.optional(z.never()),
414
+
path: z.optional(z.never()),
415
+
query: z.optional(z.never())
416
416
});
417
417
418
418
export const zGetCallWithoutParametersAndResponseData = z.object({
419
-
body: z.never().optional(),
420
-
path: z.never().optional(),
421
-
query: z.never().optional()
419
+
body: z.optional(z.never()),
420
+
path: z.optional(z.never()),
421
+
query: z.optional(z.never())
422
422
});
423
423
424
424
export const zHeadCallWithoutParametersAndResponseData = z.object({
425
-
body: z.never().optional(),
426
-
path: z.never().optional(),
427
-
query: z.never().optional()
425
+
body: z.optional(z.never()),
426
+
path: z.optional(z.never()),
427
+
query: z.optional(z.never())
428
428
});
429
429
430
430
export const zOptionsCallWithoutParametersAndResponseData = z.object({
431
-
body: z.never().optional(),
432
-
path: z.never().optional(),
433
-
query: z.never().optional()
431
+
body: z.optional(z.never()),
432
+
path: z.optional(z.never()),
433
+
query: z.optional(z.never())
434
434
});
435
435
436
436
export const zPatchCallWithoutParametersAndResponseData = z.object({
437
-
body: z.never().optional(),
438
-
path: z.never().optional(),
439
-
query: z.never().optional()
437
+
body: z.optional(z.never()),
438
+
path: z.optional(z.never()),
439
+
query: z.optional(z.never())
440
440
});
441
441
442
442
export const zPostCallWithoutParametersAndResponseData = z.object({
443
-
body: z.never().optional(),
444
-
path: z.never().optional(),
445
-
query: z.never().optional()
443
+
body: z.optional(z.never()),
444
+
path: z.optional(z.never()),
445
+
query: z.optional(z.never())
446
446
});
447
447
448
448
export const zPutCallWithoutParametersAndResponseData = z.object({
449
-
body: z.never().optional(),
450
-
path: z.never().optional(),
451
-
query: z.never().optional()
449
+
body: z.optional(z.never()),
450
+
path: z.optional(z.never()),
451
+
query: z.optional(z.never())
452
452
});
453
453
454
454
export const zCallWithDescriptionsData = z.object({
455
-
body: z.never().optional(),
456
-
path: z.never().optional(),
457
-
query: z.object({
458
-
parameterWithBreaks: z.string().optional(),
459
-
parameterWithBackticks: z.string().optional(),
460
-
parameterWithSlashes: z.string().optional(),
461
-
parameterWithExpressionPlaceholders: z.string().optional(),
462
-
parameterWithQuotes: z.string().optional(),
463
-
parameterWithReservedCharacters: z.string().optional()
464
-
}).optional()
455
+
body: z.optional(z.never()),
456
+
path: z.optional(z.never()),
457
+
query: z.optional(z.object({
458
+
parameterWithBreaks: z.optional(z.string()),
459
+
parameterWithBackticks: z.optional(z.string()),
460
+
parameterWithSlashes: z.optional(z.string()),
461
+
parameterWithExpressionPlaceholders: z.optional(z.string()),
462
+
parameterWithQuotes: z.optional(z.string()),
463
+
parameterWithReservedCharacters: z.optional(z.string())
464
+
}))
465
465
});
466
466
467
467
export const zCallWithParametersData = z.object({
468
-
body: z.never().optional(),
468
+
body: z.optional(z.never()),
469
469
path: z.object({
470
470
parameterPath: z.string(),
471
471
'api-version': z.string()
···
479
479
});
480
480
481
481
export const zCallWithWeirdParameterNamesData = z.object({
482
-
body: z.never().optional(),
482
+
body: z.optional(z.never()),
483
483
path: z.object({
484
-
'parameter.path.1': z.string().optional(),
485
-
'parameter-path-2': z.string().optional(),
486
-
'PARAMETER-PATH-3': z.string().optional(),
484
+
'parameter.path.1': z.optional(z.string()),
485
+
'parameter-path-2': z.optional(z.string()),
486
+
'PARAMETER-PATH-3': z.optional(z.string()),
487
487
'api-version': z.string()
488
488
}),
489
489
query: z.object({
490
-
default: z.string().optional(),
490
+
default: z.optional(z.string()),
491
491
'parameter-query': z.string()
492
492
}),
493
493
headers: z.object({
···
496
496
});
497
497
498
498
export const zCallWithDefaultParametersData = z.object({
499
-
body: z.never().optional(),
500
-
path: z.never().optional(),
499
+
body: z.optional(z.never()),
500
+
path: z.optional(z.never()),
501
501
query: z.object({
502
502
parameterString: z.string().default('Hello World!'),
503
503
parameterNumber: z.number().default(123),
···
508
508
'Error'
509
509
]),
510
510
parameterModel: z.object({
511
-
prop: z.string().optional()
511
+
prop: z.optional(z.string())
512
512
}).default({
513
513
prop: 'Hello World!'
514
514
})
···
516
516
});
517
517
518
518
export const zCallWithDefaultOptionalParametersData = z.object({
519
-
body: z.never().optional(),
520
-
path: z.never().optional(),
521
-
query: z.object({
522
-
parameterString: z.string().optional().default('Hello World!'),
523
-
parameterNumber: z.number().optional().default(123),
524
-
parameterBoolean: z.boolean().optional().default(true),
525
-
parameterEnum: z.enum([
519
+
body: z.optional(z.never()),
520
+
path: z.optional(z.never()),
521
+
query: z.optional(z.object({
522
+
parameterString: z.optional(z.string()).default('Hello World!'),
523
+
parameterNumber: z.optional(z.number()).default(123),
524
+
parameterBoolean: z.optional(z.boolean()).default(true),
525
+
parameterEnum: z.optional(z.enum([
526
526
'Success',
527
527
'Warning',
528
528
'Error'
529
-
]).optional()
530
-
}).optional()
529
+
]))
530
+
}))
531
531
});
532
532
533
533
export const zCallToTestOrderOfParamsData = z.object({
534
-
body: z.never().optional(),
535
-
path: z.never().optional(),
534
+
body: z.optional(z.never()),
535
+
path: z.optional(z.never()),
536
536
query: z.object({
537
-
parameterOptionalStringWithDefault: z.string().optional().default('Hello World!'),
538
-
parameterOptionalStringWithEmptyDefault: z.string().optional().default(''),
539
-
parameterOptionalStringWithNoDefault: z.string().optional(),
537
+
parameterOptionalStringWithDefault: z.optional(z.string()).default('Hello World!'),
538
+
parameterOptionalStringWithEmptyDefault: z.optional(z.string()).default(''),
539
+
parameterOptionalStringWithNoDefault: z.optional(z.string()),
540
540
parameterStringWithDefault: z.string().default('Hello World!'),
541
541
parameterStringWithEmptyDefault: z.string().default(''),
542
542
parameterStringWithNoDefault: z.string(),
543
-
parameterStringNullableWithNoDefault: z.union([
543
+
parameterStringNullableWithNoDefault: z.optional(z.union([
544
544
z.string(),
545
545
z.null()
546
-
]).optional(),
547
-
parameterStringNullableWithDefault: z.union([
546
+
])),
547
+
parameterStringNullableWithDefault: z.optional(z.union([
548
548
z.string(),
549
549
z.null()
550
-
]).optional().default(null)
550
+
])).default(null)
551
551
})
552
552
});
553
553
554
554
export const zDuplicateNameData = z.object({
555
-
body: z.never().optional(),
556
-
path: z.never().optional(),
557
-
query: z.never().optional()
555
+
body: z.optional(z.never()),
556
+
path: z.optional(z.never()),
557
+
query: z.optional(z.never())
558
558
});
559
559
560
560
export const zDuplicateName2Data = z.object({
561
-
body: z.never().optional(),
562
-
path: z.never().optional(),
563
-
query: z.never().optional()
561
+
body: z.optional(z.never()),
562
+
path: z.optional(z.never()),
563
+
query: z.optional(z.never())
564
564
});
565
565
566
566
export const zDuplicateName3Data = z.object({
567
-
body: z.never().optional(),
568
-
path: z.never().optional(),
569
-
query: z.never().optional()
567
+
body: z.optional(z.never()),
568
+
path: z.optional(z.never()),
569
+
query: z.optional(z.never())
570
570
});
571
571
572
572
export const zDuplicateName4Data = z.object({
573
-
body: z.never().optional(),
574
-
path: z.never().optional(),
575
-
query: z.never().optional()
573
+
body: z.optional(z.never()),
574
+
path: z.optional(z.never()),
575
+
query: z.optional(z.never())
576
576
});
577
577
578
578
export const zCallWithNoContentResponseData = z.object({
579
-
body: z.never().optional(),
580
-
path: z.never().optional(),
581
-
query: z.never().optional()
579
+
body: z.optional(z.never()),
580
+
path: z.optional(z.never()),
581
+
query: z.optional(z.never())
582
582
});
583
583
584
584
export const zCallWithResponseAndNoContentResponseData = z.object({
585
-
body: z.never().optional(),
586
-
path: z.never().optional(),
587
-
query: z.never().optional()
585
+
body: z.optional(z.never()),
586
+
path: z.optional(z.never()),
587
+
query: z.optional(z.never())
588
588
});
589
589
590
590
export const zCallWithResponseAndNoContentResponseResponse = z.union([
···
593
593
]);
594
594
595
595
export const zDummyAData = z.object({
596
-
body: z.never().optional(),
597
-
path: z.never().optional(),
598
-
query: z.never().optional()
596
+
body: z.optional(z.never()),
597
+
path: z.optional(z.never()),
598
+
query: z.optional(z.never())
599
599
});
600
600
601
601
export const zDummyBData = z.object({
602
-
body: z.never().optional(),
603
-
path: z.never().optional(),
604
-
query: z.never().optional()
602
+
body: z.optional(z.never()),
603
+
path: z.optional(z.never()),
604
+
query: z.optional(z.never())
605
605
});
606
606
607
607
export const zCallWithResponseData = z.object({
608
-
body: z.never().optional(),
609
-
path: z.never().optional(),
610
-
query: z.never().optional()
608
+
body: z.optional(z.never()),
609
+
path: z.optional(z.never()),
610
+
query: z.optional(z.never())
611
611
});
612
612
613
613
/**
···
616
616
export const zCallWithResponseResponse = zModelWithString;
617
617
618
618
export const zCallWithDuplicateResponsesData = z.object({
619
-
body: z.never().optional(),
620
-
path: z.never().optional(),
621
-
query: z.never().optional()
619
+
body: z.optional(z.never()),
620
+
path: z.optional(z.never()),
621
+
query: z.optional(z.never())
622
622
});
623
623
624
624
/**
···
627
627
export const zCallWithDuplicateResponsesResponse = zModelWithString;
628
628
629
629
export const zCallWithResponsesData = z.object({
630
-
body: z.never().optional(),
631
-
path: z.never().optional(),
632
-
query: z.never().optional()
630
+
body: z.optional(z.never()),
631
+
path: z.optional(z.never()),
632
+
query: z.optional(z.never())
633
633
});
634
634
635
635
export const zCallWithResponsesResponse = z.union([
636
636
z.object({
637
-
'@namespace.string': z.string().readonly().optional(),
638
-
'@namespace.integer': z.number().int().readonly().optional(),
639
-
value: z.array(zModelWithString).readonly().optional()
637
+
'@namespace.string': z.optional(z.string().readonly()),
638
+
'@namespace.integer': z.optional(z.int().readonly()),
639
+
value: z.optional(z.array(zModelWithString).readonly())
640
640
}),
641
641
zModelThatExtends,
642
642
zModelThatExtendsExtends
643
643
]);
644
644
645
645
export const zCollectionFormatData = z.object({
646
-
body: z.never().optional(),
647
-
path: z.never().optional(),
646
+
body: z.optional(z.never()),
647
+
path: z.optional(z.never()),
648
648
query: z.object({
649
649
parameterArrayCSV: z.array(z.string()),
650
650
parameterArraySSV: z.array(z.string()),
···
655
655
});
656
656
657
657
export const zTypesData = z.object({
658
-
body: z.never().optional(),
659
-
path: z.object({
660
-
id: z.number().int().optional()
661
-
}).optional(),
658
+
body: z.optional(z.never()),
659
+
path: z.optional(z.object({
660
+
id: z.optional(z.int())
661
+
})),
662
662
query: z.object({
663
663
parameterNumber: z.number().default(123),
664
664
parameterString: z.string().default('default'),
···
681
681
]);
682
682
683
683
export const zComplexTypesData = z.object({
684
-
body: z.never().optional(),
685
-
path: z.never().optional(),
684
+
body: z.optional(z.never()),
685
+
path: z.optional(z.never()),
686
686
query: z.object({
687
687
parameterObject: z.object({
688
-
first: z.object({
689
-
second: z.object({
690
-
third: z.string().optional()
691
-
}).optional()
692
-
}).optional()
688
+
first: z.optional(z.object({
689
+
second: z.optional(z.object({
690
+
third: z.optional(z.string())
691
+
}))
692
+
}))
693
693
}),
694
694
parameterReference: z.object({
695
-
prop: z.string().optional()
695
+
prop: z.optional(z.string())
696
696
})
697
697
})
698
698
});
···
703
703
export const zComplexTypesResponse = z.array(zModelWithString);
704
704
705
705
export const zCallWithResultFromHeaderData = z.object({
706
-
body: z.never().optional(),
707
-
path: z.never().optional(),
708
-
query: z.never().optional()
706
+
body: z.optional(z.never()),
707
+
path: z.optional(z.never()),
708
+
query: z.optional(z.never())
709
709
});
710
710
711
711
export const zTestErrorCodeData = z.object({
712
-
body: z.never().optional(),
713
-
path: z.never().optional(),
712
+
body: z.optional(z.never()),
713
+
path: z.optional(z.never()),
714
714
query: z.object({
715
715
status: z.string()
716
716
})
717
717
});
718
718
719
719
export const zNonAsciiæøåÆøÅöôêÊ字符串Data = z.object({
720
-
body: z.never().optional(),
721
-
path: z.never().optional(),
720
+
body: z.optional(z.never()),
721
+
path: z.optional(z.never()),
722
722
query: z.object({
723
-
'nonAsciiParamæøåÆØÅöôêÊ': z.number().int()
723
+
'nonAsciiParamæøåÆØÅöôêÊ': z.int()
724
724
})
725
725
});
726
726
···
731
731
732
732
export const zPostApiVbyApiVersionBodyData = z.object({
733
733
body: zParameterActivityParams,
734
-
path: z.never().optional(),
735
-
query: z.never().optional()
734
+
path: z.optional(z.never()),
735
+
query: z.optional(z.never())
736
736
});
737
737
738
738
/**
+1
-1
packages/openapi-ts-tests/test/__snapshots__/3.0.x/array-items-one-of-length-1/zod.gen.ts
+1
-1
packages/openapi-ts-tests/test/__snapshots__/3.0.x/array-items-one-of-length-1/zod.gen.ts
+5
-5
packages/openapi-ts-tests/test/__snapshots__/3.0.x/plugins/@hey-api/transformers/type-format-zod/zod.gen.ts
+5
-5
packages/openapi-ts-tests/test/__snapshots__/3.0.x/plugins/@hey-api/transformers/type-format-zod/zod.gen.ts
···
3
3
import { z } from 'zod';
4
4
5
5
export const zFoo = z.object({
6
-
bar: z.number().int().optional(),
6
+
bar: z.optional(z.int()),
7
7
foo: z.coerce.bigint().default(BigInt(0)),
8
8
id: z.string()
9
9
});
10
10
11
11
export const zBar = z.object({
12
-
foo: z.number().int()
12
+
foo: z.int()
13
13
});
14
14
15
15
export const zPostFooData = z.object({
16
-
body: z.never().optional(),
17
-
path: z.never().optional(),
18
-
query: z.never().optional()
16
+
body: z.optional(z.never()),
17
+
path: z.optional(z.never()),
18
+
query: z.optional(z.never())
19
19
});
20
20
21
21
/**
+405
-405
packages/openapi-ts-tests/test/__snapshots__/3.0.x/plugins/zod/default/zod.gen.ts
+405
-405
packages/openapi-ts-tests/test/__snapshots__/3.0.x/plugins/zod/default/zod.gen.ts
···
13
13
*
14
14
* Fourth line
15
15
*/
16
-
export const zCamelCaseCommentWithBreaks = z.number().int();
16
+
export const zCamelCaseCommentWithBreaks = z.int();
17
17
18
18
/**
19
19
* Testing multiline comments in string: First line
···
21
21
*
22
22
* Fourth line
23
23
*/
24
-
export const zCommentWithBreaks = z.number().int();
24
+
export const zCommentWithBreaks = z.int();
25
25
26
26
/**
27
27
* Testing backticks in string: `backticks` and ```multiple backticks``` should work
28
28
*/
29
-
export const zCommentWithBackticks = z.number().int();
29
+
export const zCommentWithBackticks = z.int();
30
30
31
31
/**
32
32
* Testing backticks and quotes in string: `backticks`, 'quotes', "double quotes" and ```multiple backticks``` should work
33
33
*/
34
-
export const zCommentWithBackticksAndQuotes = z.number().int();
34
+
export const zCommentWithBackticksAndQuotes = z.int();
35
35
36
36
/**
37
37
* Testing slashes in string: \backwards\\\ and /forwards/// should work
38
38
*/
39
-
export const zCommentWithSlashes = z.number().int();
39
+
export const zCommentWithSlashes = z.int();
40
40
41
41
/**
42
42
* Testing expression placeholders in string: ${expression} should work
43
43
*/
44
-
export const zCommentWithExpressionPlaceholders = z.number().int();
44
+
export const zCommentWithExpressionPlaceholders = z.int();
45
45
46
46
/**
47
47
* Testing quotes in string: 'single quote''' and "double quotes""" should work
48
48
*/
49
-
export const zCommentWithQuotes = z.number().int();
49
+
export const zCommentWithQuotes = z.int();
50
50
51
51
/**
52
52
* Testing reserved characters in string: * inline * and ** inline ** should work
53
53
*/
54
-
export const zCommentWithReservedCharacters = z.number().int();
54
+
export const zCommentWithReservedCharacters = z.int();
55
55
56
56
/**
57
57
* This is a simple number
58
58
*/
59
-
export const zSimpleInteger = z.number().int();
59
+
export const zSimpleInteger = z.int();
60
60
61
61
/**
62
62
* This is a simple boolean
···
82
82
* This is a model with one string property
83
83
*/
84
84
export const zModelWithString = z.object({
85
-
prop: z.string().optional()
85
+
prop: z.optional(z.string())
86
86
});
87
87
88
88
/**
···
137
137
/**
138
138
* This is a simple array with numbers
139
139
*/
140
-
export const zArrayWithNumbers = z.array(z.number().int());
140
+
export const zArrayWithNumbers = z.array(z.int());
141
141
142
142
/**
143
143
* This is a simple array with booleans
···
163
163
* This is a simple array with properties
164
164
*/
165
165
export const zArrayWithProperties = z.array(z.object({
166
-
'16x16': zCamelCaseCommentWithBreaks.optional(),
167
-
bar: z.string().optional()
166
+
'16x16': z.optional(zCamelCaseCommentWithBreaks),
167
+
bar: z.optional(z.string())
168
168
}));
169
169
170
170
/**
···
172
172
*/
173
173
export const zArrayWithAnyOfProperties = z.array(z.union([
174
174
z.object({
175
-
foo: z.string().optional().default('test')
175
+
foo: z.optional(z.string()).default('test')
176
176
}),
177
177
z.object({
178
-
bar: z.string().optional()
178
+
bar: z.optional(z.string())
179
179
})
180
180
]));
181
181
182
182
export const zAnyOfAnyAndNull = z.object({
183
-
data: z.unknown().optional()
183
+
data: z.optional(z.unknown())
184
184
});
185
185
186
186
/**
187
187
* This is a simple array with any of properties
188
188
*/
189
189
export const zAnyOfArrays = z.object({
190
-
results: z.array(z.union([
190
+
results: z.optional(z.array(z.union([
191
191
z.object({
192
-
foo: z.string().optional()
192
+
foo: z.optional(z.string())
193
193
}),
194
194
z.object({
195
-
bar: z.string().optional()
195
+
bar: z.optional(z.string())
196
196
})
197
-
])).optional()
197
+
])))
198
198
});
199
199
200
200
/**
···
203
203
export const zDictionaryWithString = z.object({});
204
204
205
205
export const zDictionaryWithPropertiesAndAdditionalProperties = z.object({
206
-
foo: z.number().optional(),
207
-
bar: z.boolean().optional()
206
+
foo: z.optional(z.number()),
207
+
bar: z.optional(z.boolean())
208
208
});
209
209
210
210
/**
···
220
220
/**
221
221
* This is a string dictionary
222
222
*/
223
-
export const zDictionaryWithDictionary = z.record(z.object({}));
223
+
export const zDictionaryWithDictionary = z.record(z.string(), z.object({}));
224
224
225
225
/**
226
226
* This is a complex dictionary
227
227
*/
228
-
export const zDictionaryWithProperties = z.record(z.object({
229
-
foo: z.string().optional(),
230
-
bar: z.string().optional()
228
+
export const zDictionaryWithProperties = z.record(z.string(), z.object({
229
+
foo: z.optional(z.string()),
230
+
bar: z.optional(z.string())
231
231
}));
232
232
233
233
/**
234
234
* This is a model with one number property
235
235
*/
236
236
export const zModelWithInteger = z.object({
237
-
prop: z.number().int().optional()
237
+
prop: z.optional(z.int())
238
238
});
239
239
240
240
/**
241
241
* This is a model with one boolean property
242
242
*/
243
243
export const zModelWithBoolean = z.object({
244
-
prop: z.boolean().optional()
244
+
prop: z.optional(z.boolean())
245
245
});
246
246
247
247
/**
248
248
* This is a model with one string property
249
249
*/
250
250
export const zModelWithStringError = z.object({
251
-
prop: z.string().optional()
251
+
prop: z.optional(z.string())
252
252
});
253
253
254
254
/**
···
260
260
* This is a model with one string property
261
261
*/
262
262
export const zModelWithNullableString = z.object({
263
-
nullableProp1: z.union([
263
+
nullableProp1: z.optional(z.union([
264
264
z.string(),
265
265
z.null()
266
-
]).optional(),
266
+
])),
267
267
nullableRequiredProp1: z.union([
268
268
z.string(),
269
269
z.null()
270
270
]),
271
-
nullableProp2: z.union([
271
+
nullableProp2: z.optional(z.union([
272
272
z.string(),
273
273
z.null()
274
-
]).optional(),
274
+
])),
275
275
nullableRequiredProp2: z.union([
276
276
z.string(),
277
277
z.null()
278
278
]),
279
-
'foo_bar-enum': z.enum([
279
+
'foo_bar-enum': z.optional(z.enum([
280
280
'Success',
281
281
'Warning',
282
282
'Error',
283
283
'ØÆÅ字符串'
284
-
]).optional()
284
+
]))
285
285
});
286
286
287
287
/**
288
288
* This is a model with one enum
289
289
*/
290
290
export const zModelWithEnum = z.object({
291
-
'foo_bar-enum': z.enum([
291
+
'foo_bar-enum': z.optional(z.enum([
292
292
'Success',
293
293
'Warning',
294
294
'Error',
295
295
'ØÆÅ字符串'
296
-
]).optional(),
297
-
statusCode: z.enum([
296
+
])),
297
+
statusCode: z.optional(z.enum([
298
298
'100',
299
299
'200 FOO',
300
300
'300 FOO_BAR',
301
301
'400 foo-bar',
302
302
'500 foo.bar',
303
303
'600 foo&bar'
304
-
]).optional(),
305
-
bool: z.unknown().optional()
304
+
])),
305
+
bool: z.optional(z.unknown())
306
306
});
307
307
308
308
/**
309
309
* This is a model with one enum with escaped name
310
310
*/
311
311
export const zModelWithEnumWithHyphen = z.object({
312
-
'foo-bar-baz-qux': z.enum([
312
+
'foo-bar-baz-qux': z.optional(z.enum([
313
313
'3.0'
314
-
]).optional()
314
+
]))
315
315
});
316
316
317
317
/**
318
318
* This is a model with one enum
319
319
*/
320
320
export const zModelWithEnumFromDescription = z.object({
321
-
test: z.number().int().optional()
321
+
test: z.optional(z.int())
322
322
});
323
323
324
324
/**
325
325
* This is a model with nested enums
326
326
*/
327
327
export const zModelWithNestedEnums = z.object({
328
-
dictionaryWithEnum: z.object({}).optional(),
329
-
dictionaryWithEnumFromDescription: z.object({}).optional(),
330
-
arrayWithEnum: z.array(z.enum([
328
+
dictionaryWithEnum: z.optional(z.object({})),
329
+
dictionaryWithEnumFromDescription: z.optional(z.object({})),
330
+
arrayWithEnum: z.optional(z.array(z.enum([
331
331
'Success',
332
332
'Warning',
333
333
'Error'
334
-
])).optional(),
335
-
arrayWithDescription: z.array(z.number().int()).optional(),
336
-
'foo_bar-enum': z.enum([
334
+
]))),
335
+
arrayWithDescription: z.optional(z.array(z.int())),
336
+
'foo_bar-enum': z.optional(z.enum([
337
337
'Success',
338
338
'Warning',
339
339
'Error',
340
340
'ØÆÅ字符串'
341
-
]).optional()
341
+
]))
342
342
});
343
343
344
344
/**
···
351
351
z.string(),
352
352
z.null()
353
353
]),
354
-
string: z.string().optional(),
355
-
number: z.number().optional(),
356
-
boolean: z.boolean().optional(),
357
-
reference: zModelWithString.optional(),
358
-
'property with space': z.string().optional(),
359
-
default: z.string().optional(),
360
-
try: z.string().optional(),
361
-
'@namespace.string': z.string().readonly().optional(),
362
-
'@namespace.integer': z.number().int().readonly().optional()
354
+
string: z.optional(z.string()),
355
+
number: z.optional(z.number()),
356
+
boolean: z.optional(z.boolean()),
357
+
reference: z.optional(zModelWithString),
358
+
'property with space': z.optional(z.string()),
359
+
default: z.optional(z.string()),
360
+
try: z.optional(z.string()),
361
+
'@namespace.string': z.optional(z.string().readonly()),
362
+
'@namespace.integer': z.optional(z.int().readonly())
363
363
});
364
364
365
365
/**
366
366
* This is a model with one property containing a reference
367
367
*/
368
368
export const zModelWithReference = z.object({
369
-
prop: zModelWithProperties.optional()
369
+
prop: z.optional(zModelWithProperties)
370
370
});
371
371
372
372
export const zModelWithReadOnlyAndWriteOnly = z.object({
···
378
378
* This is a model with one property containing an array
379
379
*/
380
380
export const zModelWithArrayReadOnlyAndWriteOnly = z.object({
381
-
prop: z.array(zModelWithReadOnlyAndWriteOnly).optional(),
382
-
propWithFile: z.array(z.string()).optional(),
383
-
propWithNumber: z.array(z.number()).optional()
381
+
prop: z.optional(z.array(zModelWithReadOnlyAndWriteOnly)),
382
+
propWithFile: z.optional(z.array(z.string())),
383
+
propWithNumber: z.optional(z.array(z.number()))
384
384
});
385
385
386
386
/**
387
387
* This is a model with one property containing an array
388
388
*/
389
389
export const zModelWithArray = z.object({
390
-
prop: z.array(zModelWithString).optional(),
391
-
propWithFile: z.array(z.string()).optional(),
392
-
propWithNumber: z.array(z.number()).optional()
390
+
prop: z.optional(z.array(zModelWithString)),
391
+
propWithFile: z.optional(z.array(z.string())),
392
+
propWithNumber: z.optional(z.array(z.number()))
393
393
});
394
394
395
395
/**
396
396
* This is a model with one property containing a dictionary
397
397
*/
398
398
export const zModelWithDictionary = z.object({
399
-
prop: z.object({}).optional()
399
+
prop: z.optional(z.object({}))
400
400
});
401
401
402
402
/**
···
404
404
* @deprecated
405
405
*/
406
406
export const zDeprecatedModel = z.object({
407
-
prop: z.string().optional()
407
+
prop: z.optional(z.string())
408
408
});
409
409
410
410
/**
411
411
* This is a model with one property containing a circular reference
412
412
*/
413
-
export const zModelWithCircularReference: z.AnyZodObject = z.object({
414
-
prop: z.lazy(() => {
413
+
export const zModelWithCircularReference = z.object({
414
+
prop: z.optional(z.lazy(() => {
415
415
return zModelWithCircularReference;
416
-
}).optional()
416
+
}))
417
417
});
418
418
419
419
/**
420
420
* This is a model with one property with a 'one of' relationship
421
421
*/
422
422
export const zCompositionWithOneOf = z.object({
423
-
propA: z.union([
423
+
propA: z.optional(z.union([
424
424
zModelWithString,
425
425
zModelWithEnum,
426
426
zModelWithArray,
427
427
zModelWithDictionary
428
-
]).optional()
428
+
]))
429
429
});
430
430
431
431
/**
432
432
* This is a model with one property with a 'one of' relationship where the options are not $ref
433
433
*/
434
434
export const zCompositionWithOneOfAnonymous = z.object({
435
-
propA: z.union([
435
+
propA: z.optional(z.union([
436
436
z.object({
437
-
propA: z.string().optional()
437
+
propA: z.optional(z.string())
438
438
}),
439
439
z.string(),
440
-
z.number().int()
441
-
]).optional()
440
+
z.int()
441
+
]))
442
442
});
443
443
444
444
/**
···
446
446
*/
447
447
export const zModelCircle = z.object({
448
448
kind: z.string(),
449
-
radius: z.number().optional()
449
+
radius: z.optional(z.number())
450
450
});
451
451
452
452
/**
···
454
454
*/
455
455
export const zModelSquare = z.object({
456
456
kind: z.string(),
457
-
sideLength: z.number().optional()
457
+
sideLength: z.optional(z.number())
458
458
});
459
459
460
460
/**
···
473
473
* This is a model with one property with a 'any of' relationship
474
474
*/
475
475
export const zCompositionWithAnyOf = z.object({
476
-
propA: z.union([
476
+
propA: z.optional(z.union([
477
477
zModelWithString,
478
478
zModelWithEnum,
479
479
zModelWithArray,
480
480
zModelWithDictionary
481
-
]).optional()
481
+
]))
482
482
});
483
483
484
484
/**
485
485
* This is a model with one property with a 'any of' relationship where the options are not $ref
486
486
*/
487
487
export const zCompositionWithAnyOfAnonymous = z.object({
488
-
propA: z.union([
488
+
propA: z.optional(z.union([
489
489
z.object({
490
-
propA: z.string().optional()
490
+
propA: z.optional(z.string())
491
491
}),
492
492
z.string(),
493
-
z.number().int()
494
-
]).optional()
493
+
z.int()
494
+
]))
495
495
});
496
496
497
497
/**
498
498
* This is a model with nested 'any of' property with a type null
499
499
*/
500
500
export const zCompositionWithNestedAnyAndTypeNull = z.object({
501
-
propA: z.union([
501
+
propA: z.optional(z.union([
502
502
z.array(z.union([
503
503
zModelWithDictionary,
504
504
z.null()
···
507
507
zModelWithArray,
508
508
z.null()
509
509
]))
510
-
]).optional()
510
+
]))
511
511
});
512
512
513
513
export const z3eNum1Период = z.enum([
···
523
523
* This is a model with one property with a 'any of' relationship where the options are not $ref
524
524
*/
525
525
export const zCompositionWithNestedAnyOfAndNull = z.object({
526
-
propA: z.union([
526
+
propA: z.optional(z.union([
527
527
z.array(z.union([
528
528
z3eNum1Период,
529
529
zConstValue
530
530
])),
531
531
z.null()
532
-
]).optional()
532
+
]))
533
533
});
534
534
535
535
/**
536
536
* This is a model with one property with a 'one of' relationship
537
537
*/
538
538
export const zCompositionWithOneOfAndNullable = z.object({
539
-
propA: z.union([
539
+
propA: z.optional(z.union([
540
540
z.object({
541
-
boolean: z.boolean().optional()
541
+
boolean: z.optional(z.boolean())
542
542
}),
543
543
zModelWithEnum,
544
544
zModelWithArray,
545
545
zModelWithDictionary,
546
546
z.null()
547
-
]).optional()
547
+
]))
548
548
});
549
549
550
550
/**
551
551
* This is a model that contains a simple dictionary within composition
552
552
*/
553
553
export const zCompositionWithOneOfAndSimpleDictionary = z.object({
554
-
propA: z.union([
554
+
propA: z.optional(z.union([
555
555
z.boolean(),
556
556
z.object({})
557
-
]).optional()
557
+
]))
558
558
});
559
559
560
560
/**
561
561
* This is a model that contains a dictionary of simple arrays within composition
562
562
*/
563
563
export const zCompositionWithOneOfAndSimpleArrayDictionary = z.object({
564
-
propA: z.union([
564
+
propA: z.optional(z.union([
565
565
z.boolean(),
566
566
z.object({})
567
-
]).optional()
567
+
]))
568
568
});
569
569
570
570
/**
571
571
* This is a model that contains a dictionary of complex arrays (composited) within composition
572
572
*/
573
573
export const zCompositionWithOneOfAndComplexArrayDictionary = z.object({
574
-
propA: z.union([
574
+
propA: z.optional(z.union([
575
575
z.boolean(),
576
576
z.object({})
577
-
]).optional()
577
+
]))
578
578
});
579
579
580
580
/**
581
581
* This is a model with one property with a 'all of' relationship
582
582
*/
583
583
export const zCompositionWithAllOfAndNullable = z.object({
584
-
propA: z.union([
584
+
propA: z.optional(z.union([
585
585
z.object({
586
-
boolean: z.boolean().optional()
586
+
boolean: z.optional(z.boolean())
587
587
}).and(zModelWithEnum).and(zModelWithArray).and(zModelWithDictionary),
588
588
z.null()
589
-
]).optional()
589
+
]))
590
590
});
591
591
592
592
/**
593
593
* This is a model with one property with a 'any of' relationship
594
594
*/
595
595
export const zCompositionWithAnyOfAndNullable = z.object({
596
-
propA: z.union([
596
+
propA: z.optional(z.union([
597
597
z.object({
598
-
boolean: z.boolean().optional()
598
+
boolean: z.optional(z.boolean())
599
599
}),
600
600
zModelWithEnum,
601
601
zModelWithArray,
602
602
zModelWithDictionary,
603
603
z.null()
604
-
]).optional()
604
+
]))
605
605
});
606
606
607
607
/**
608
608
* This is a base model with two simple optional properties
609
609
*/
610
610
export const zCompositionBaseModel = z.object({
611
-
firstName: z.string().optional(),
612
-
lastname: z.string().optional()
611
+
firstName: z.optional(z.string()),
612
+
lastname: z.optional(z.string())
613
613
});
614
614
615
615
/**
···
645
645
* This is a model with duplicated properties
646
646
*/
647
647
export const zModelWithDuplicateProperties = z.object({
648
-
prop: zModelWithString.optional()
648
+
prop: z.optional(zModelWithString)
649
649
});
650
650
651
651
/**
652
652
* This is a model with ordered properties
653
653
*/
654
654
export const zModelWithOrderedProperties = z.object({
655
-
zebra: z.string().optional(),
656
-
apple: z.string().optional(),
657
-
hawaii: z.string().optional()
655
+
zebra: z.optional(z.string()),
656
+
apple: z.optional(z.string()),
657
+
hawaii: z.optional(z.string())
658
658
});
659
659
660
660
/**
661
661
* This is a model with duplicated imports
662
662
*/
663
663
export const zModelWithDuplicateImports = z.object({
664
-
propA: zModelWithString.optional(),
665
-
propB: zModelWithString.optional(),
666
-
propC: zModelWithString.optional()
664
+
propA: z.optional(zModelWithString),
665
+
propB: z.optional(zModelWithString),
666
+
propC: z.optional(zModelWithString)
667
667
});
668
668
669
669
/**
670
670
* This is a model that extends another model
671
671
*/
672
672
export const zModelThatExtends = zModelWithString.and(z.object({
673
-
propExtendsA: z.string().optional(),
674
-
propExtendsB: zModelWithString.optional()
673
+
propExtendsA: z.optional(z.string()),
674
+
propExtendsB: z.optional(zModelWithString)
675
675
}));
676
676
677
677
/**
678
678
* This is a model that extends another model
679
679
*/
680
680
export const zModelThatExtendsExtends = zModelWithString.and(zModelThatExtends).and(z.object({
681
-
propExtendsC: z.string().optional(),
682
-
propExtendsD: zModelWithString.optional()
681
+
propExtendsC: z.optional(z.string()),
682
+
propExtendsD: z.optional(zModelWithString)
683
683
}));
684
684
685
685
/**
···
688
688
export const zModelWithPattern = z.object({
689
689
key: z.string().max(64).regex(/^[a-zA-Z0-9_]*$/),
690
690
name: z.string().max(255),
691
-
enabled: z.boolean().readonly().optional(),
692
-
modified: z.string().datetime().readonly().optional(),
693
-
id: z.string().regex(/^\d{2}-\d{3}-\d{4}$/).optional(),
694
-
text: z.string().regex(/^\w+$/).optional(),
695
-
patternWithSingleQuotes: z.string().regex(/^[a-zA-Z0-9']*$/).optional(),
696
-
patternWithNewline: z.string().regex(/aaa\nbbb/).optional(),
697
-
patternWithBacktick: z.string().regex(/aaa`bbb/).optional()
691
+
enabled: z.optional(z.boolean().readonly()),
692
+
modified: z.optional(z.iso.datetime().readonly()),
693
+
id: z.optional(z.string().regex(/^\d{2}-\d{3}-\d{4}$/)),
694
+
text: z.optional(z.string().regex(/^\w+$/)),
695
+
patternWithSingleQuotes: z.optional(z.string().regex(/^[a-zA-Z0-9']*$/)),
696
+
patternWithNewline: z.optional(z.string().regex(/aaa\nbbb/)),
697
+
patternWithBacktick: z.optional(z.string().regex(/aaa`bbb/))
698
698
});
699
699
700
700
export const zFile = z.object({
701
-
id: z.string().min(1).readonly().optional(),
702
-
updated_at: z.string().datetime().readonly().optional(),
703
-
created_at: z.string().datetime().readonly().optional(),
701
+
id: z.optional(z.string().min(1).readonly()),
702
+
updated_at: z.optional(z.iso.datetime().readonly()),
703
+
created_at: z.optional(z.iso.datetime().readonly()),
704
704
mime: z.string().min(1).max(24),
705
-
file: z.string().url().readonly().optional()
705
+
file: z.optional(z.url().readonly())
706
706
});
707
707
708
708
export const zDefault = z.object({
709
-
name: z.string().optional()
709
+
name: z.optional(z.string())
710
710
});
711
711
712
712
export const zPageable = z.object({
713
-
page: z.number().int().gte(0).optional().default(0),
714
-
size: z.number().int().gte(1).optional(),
715
-
sort: z.array(z.string()).optional()
713
+
page: z.optional(z.int().gte(0)).default(0),
714
+
size: z.optional(z.int().gte(1)),
715
+
sort: z.optional(z.array(z.string()))
716
716
});
717
717
718
718
/**
···
731
731
export const zFreeFormObjectWithAdditionalPropertiesEqEmptyObject = z.object({});
732
732
733
733
export const zModelWithConst = z.object({
734
-
String: z.enum([
734
+
String: z.optional(z.enum([
735
735
'String'
736
-
]).optional(),
737
-
number: z.unknown().optional(),
738
-
null: z.unknown().optional(),
739
-
withType: z.enum([
736
+
])),
737
+
number: z.optional(z.unknown()),
738
+
null: z.optional(z.unknown()),
739
+
withType: z.optional(z.enum([
740
740
'Some string'
741
-
]).optional()
741
+
]))
742
742
});
743
743
744
744
/**
745
745
* This is a model with one property and additionalProperties: true
746
746
*/
747
747
export const zModelWithAdditionalPropertiesEqTrue = z.object({
748
-
prop: z.string().optional()
748
+
prop: z.optional(z.string())
749
749
});
750
750
751
751
export const zNestedAnyOfArraysNullable = z.object({
752
-
nullableArray: z.union([
752
+
nullableArray: z.optional(z.union([
753
753
z.array(z.union([
754
754
z.string(),
755
755
z.boolean()
756
756
])),
757
757
z.null()
758
-
]).optional()
758
+
]))
759
759
});
760
760
761
761
/**
···
772
772
})
773
773
]), z.object({
774
774
baz: z.union([
775
-
z.number().int().gte(0),
775
+
z.int().gte(0),
776
776
z.null()
777
777
]),
778
-
qux: z.number().int().gte(0)
778
+
qux: z.int().gte(0)
779
779
}));
780
780
781
781
/**
···
783
783
*/
784
784
export const zNullableObject = z.union([
785
785
z.object({
786
-
foo: z.string().optional()
786
+
foo: z.optional(z.string())
787
787
}),
788
788
z.null()
789
789
]).default(null);
···
794
794
export const zCharactersInDescription = z.string();
795
795
796
796
export const zModelWithNullableObject = z.object({
797
-
data: zNullableObject.optional()
797
+
data: z.optional(zNullableObject)
798
798
});
799
799
800
800
export const zModelWithOneOfEnum = z.union([
···
814
814
])
815
815
}),
816
816
z.object({
817
-
content: z.string().datetime(),
817
+
content: z.iso.datetime(),
818
818
foo: z.enum([
819
819
'Quux'
820
820
])
821
821
}),
822
822
z.object({
823
823
content: z.tuple([
824
-
z.string().datetime(),
825
-
z.string().datetime()
824
+
z.iso.datetime(),
825
+
z.iso.datetime()
826
826
]),
827
827
foo: z.enum([
828
828
'Corge'
···
841
841
]);
842
842
843
843
export const zModelWithNestedArrayEnumsData = z.object({
844
-
foo: z.array(zModelWithNestedArrayEnumsDataFoo).optional(),
845
-
bar: z.array(zModelWithNestedArrayEnumsDataBar).optional()
844
+
foo: z.optional(z.array(zModelWithNestedArrayEnumsDataFoo)),
845
+
bar: z.optional(z.array(zModelWithNestedArrayEnumsDataBar))
846
846
});
847
847
848
848
export const zModelWithNestedArrayEnums = z.object({
849
-
array_strings: z.array(z.string()).optional(),
850
-
data: zModelWithNestedArrayEnumsData.optional()
849
+
array_strings: z.optional(z.array(z.string())),
850
+
data: z.optional(zModelWithNestedArrayEnumsData)
851
851
});
852
852
853
853
export const zModelWithNestedCompositionEnums = z.object({
854
-
foo: zModelWithNestedArrayEnumsDataFoo.optional()
854
+
foo: z.optional(zModelWithNestedArrayEnumsDataFoo)
855
855
});
856
856
857
857
export const zModelWithConstantSizeArray = z.tuple([
···
920
920
]);
921
921
922
922
export const zModelWithNumericEnumUnion = z.object({
923
-
value: z.unknown().optional()
923
+
value: z.optional(z.unknown())
924
924
});
925
925
926
926
/**
927
927
* Some description with `back ticks`
928
928
*/
929
929
export const zModelWithBackticksInDescription = z.object({
930
-
template: z.string().optional()
930
+
template: z.optional(z.string())
931
931
});
932
932
933
933
export const zModelWithOneOfAndProperties = z.intersection(z.union([
···
935
935
zNonAsciiStringæøåÆøÅöôêÊ字符串
936
936
]), z.object({
937
937
baz: z.union([
938
-
z.number().int().gte(0),
938
+
z.int().gte(0),
939
939
z.null()
940
940
]),
941
-
qux: z.number().int().gte(0)
941
+
qux: z.int().gte(0)
942
942
}));
943
943
944
944
/**
···
967
967
export const zDeleteFooData2 = z.string();
968
968
969
969
export const zSchemaWithFormRestrictedKeys = z.object({
970
-
description: z.string().optional(),
971
-
'x-enum-descriptions': z.string().optional(),
972
-
'x-enum-varnames': z.string().optional(),
973
-
'x-enumNames': z.string().optional(),
974
-
title: z.string().optional(),
975
-
object: z.object({
976
-
description: z.string().optional(),
977
-
'x-enum-descriptions': z.string().optional(),
978
-
'x-enum-varnames': z.string().optional(),
979
-
'x-enumNames': z.string().optional(),
980
-
title: z.string().optional()
981
-
}).optional(),
982
-
array: z.array(z.object({
983
-
description: z.string().optional(),
984
-
'x-enum-descriptions': z.string().optional(),
985
-
'x-enum-varnames': z.string().optional(),
986
-
'x-enumNames': z.string().optional(),
987
-
title: z.string().optional()
988
-
})).optional()
970
+
description: z.optional(z.string()),
971
+
'x-enum-descriptions': z.optional(z.string()),
972
+
'x-enum-varnames': z.optional(z.string()),
973
+
'x-enumNames': z.optional(z.string()),
974
+
title: z.optional(z.string()),
975
+
object: z.optional(z.object({
976
+
description: z.optional(z.string()),
977
+
'x-enum-descriptions': z.optional(z.string()),
978
+
'x-enum-varnames': z.optional(z.string()),
979
+
'x-enumNames': z.optional(z.string()),
980
+
title: z.optional(z.string())
981
+
})),
982
+
array: z.optional(z.array(z.object({
983
+
description: z.optional(z.string()),
984
+
'x-enum-descriptions': z.optional(z.string()),
985
+
'x-enum-varnames': z.optional(z.string()),
986
+
'x-enumNames': z.optional(z.string()),
987
+
title: z.optional(z.string())
988
+
})))
989
989
});
990
990
991
991
/**
992
992
* This schema was giving PascalCase transformations a hard time
993
993
*/
994
994
export const zIoK8sApimachineryPkgApisMetaV1Preconditions = z.object({
995
-
resourceVersion: z.string().optional(),
996
-
uid: z.string().optional()
995
+
resourceVersion: z.optional(z.string()),
996
+
uid: z.optional(z.string())
997
997
});
998
998
999
999
/**
1000
1000
* This schema was giving PascalCase transformations a hard time
1001
1001
*/
1002
1002
export const zIoK8sApimachineryPkgApisMetaV1DeleteOptions = z.object({
1003
-
preconditions: zIoK8sApimachineryPkgApisMetaV1Preconditions.optional()
1003
+
preconditions: z.optional(zIoK8sApimachineryPkgApisMetaV1Preconditions)
1004
1004
});
1005
1005
1006
1006
export const zAdditionalPropertiesUnknownIssue = z.object({});
···
1012
1012
}));
1013
1013
1014
1014
export const zAdditionalPropertiesIntegerIssue = z.object({
1015
-
value: z.number().int()
1015
+
value: z.int()
1016
1016
});
1017
1017
1018
1018
export const zGenericSchemaDuplicateIssue1SystemBoolean = z.object({
1019
-
item: z.boolean().optional(),
1020
-
error: z.union([
1019
+
item: z.optional(z.boolean()),
1020
+
error: z.optional(z.union([
1021
1021
z.string(),
1022
1022
z.null()
1023
-
]).optional(),
1024
-
hasError: z.boolean().readonly().optional(),
1025
-
data: z.object({}).optional()
1023
+
])),
1024
+
hasError: z.optional(z.boolean().readonly()),
1025
+
data: z.optional(z.object({}))
1026
1026
});
1027
1027
1028
1028
export const zGenericSchemaDuplicateIssue1SystemString = z.object({
1029
-
item: z.union([
1029
+
item: z.optional(z.union([
1030
1030
z.string(),
1031
1031
z.null()
1032
-
]).optional(),
1033
-
error: z.union([
1032
+
])),
1033
+
error: z.optional(z.union([
1034
1034
z.string(),
1035
1035
z.null()
1036
-
]).optional(),
1037
-
hasError: z.boolean().readonly().optional()
1036
+
])),
1037
+
hasError: z.optional(z.boolean().readonly())
1038
1038
});
1039
1039
1040
1040
export const zOneOfAllOfIssue = z.union([
···
1056
1056
*
1057
1057
* Fourth line
1058
1058
*/
1059
-
export const zCamelCaseCommentWithBreaksWritable = z.number().int();
1059
+
export const zCamelCaseCommentWithBreaksWritable = z.int();
1060
1060
1061
1061
/**
1062
1062
* Testing multiline comments in string: First line
···
1064
1064
*
1065
1065
* Fourth line
1066
1066
*/
1067
-
export const zCommentWithBreaksWritable = z.number().int();
1067
+
export const zCommentWithBreaksWritable = z.int();
1068
1068
1069
1069
/**
1070
1070
* Testing backticks in string: `backticks` and ```multiple backticks``` should work
1071
1071
*/
1072
-
export const zCommentWithBackticksWritable = z.number().int();
1072
+
export const zCommentWithBackticksWritable = z.int();
1073
1073
1074
1074
/**
1075
1075
* Testing backticks and quotes in string: `backticks`, 'quotes', "double quotes" and ```multiple backticks``` should work
1076
1076
*/
1077
-
export const zCommentWithBackticksAndQuotesWritable = z.number().int();
1077
+
export const zCommentWithBackticksAndQuotesWritable = z.int();
1078
1078
1079
1079
/**
1080
1080
* Testing slashes in string: \backwards\\\ and /forwards/// should work
1081
1081
*/
1082
-
export const zCommentWithSlashesWritable = z.number().int();
1082
+
export const zCommentWithSlashesWritable = z.int();
1083
1083
1084
1084
/**
1085
1085
* Testing expression placeholders in string: ${expression} should work
1086
1086
*/
1087
-
export const zCommentWithExpressionPlaceholdersWritable = z.number().int();
1087
+
export const zCommentWithExpressionPlaceholdersWritable = z.int();
1088
1088
1089
1089
/**
1090
1090
* Testing quotes in string: 'single quote''' and "double quotes""" should work
1091
1091
*/
1092
-
export const zCommentWithQuotesWritable = z.number().int();
1092
+
export const zCommentWithQuotesWritable = z.int();
1093
1093
1094
1094
/**
1095
1095
* Testing reserved characters in string: * inline * and ** inline ** should work
1096
1096
*/
1097
-
export const zCommentWithReservedCharactersWritable = z.number().int();
1097
+
export const zCommentWithReservedCharactersWritable = z.int();
1098
1098
1099
1099
/**
1100
1100
* This is a simple number
1101
1101
*/
1102
-
export const zSimpleIntegerWritable = z.number().int();
1102
+
export const zSimpleIntegerWritable = z.int();
1103
1103
1104
1104
/**
1105
1105
* This is a simple boolean
···
1168
1168
/**
1169
1169
* This is a simple array with numbers
1170
1170
*/
1171
-
export const zArrayWithNumbersWritable = z.array(z.number().int());
1171
+
export const zArrayWithNumbersWritable = z.array(z.int());
1172
1172
1173
1173
/**
1174
1174
* This is a simple array with booleans
···
1188
1188
/**
1189
1189
* This is a string dictionary
1190
1190
*/
1191
-
export const zDictionaryWithDictionaryWritable = z.record(z.object({}));
1191
+
export const zDictionaryWithDictionaryWritable = z.record(z.string(), z.object({}));
1192
1192
1193
1193
/**
1194
1194
* `Comment` or `VoiceComment`. The JSON object for adding voice comments to tickets is different. See [Adding voice comments to tickets](/documentation/ticketing/managing-tickets/adding-voice-comments-to-tickets)
···
1204
1204
* This is a model with one property containing an array
1205
1205
*/
1206
1206
export const zModelWithArrayReadOnlyAndWriteOnlyWritable = z.object({
1207
-
prop: z.array(zModelWithReadOnlyAndWriteOnlyWritable).optional(),
1208
-
propWithFile: z.array(z.string()).optional(),
1209
-
propWithNumber: z.array(z.number()).optional()
1207
+
prop: z.optional(z.array(zModelWithReadOnlyAndWriteOnlyWritable)),
1208
+
propWithFile: z.optional(z.array(z.string())),
1209
+
propWithNumber: z.optional(z.array(z.number()))
1210
1210
});
1211
1211
1212
1212
export const z3eNum1ПериодWritable = z.enum([
···
1354
1354
export const zSimpleFormData = zModelWithString;
1355
1355
1356
1356
export const zExportData = z.object({
1357
-
body: z.never().optional(),
1358
-
path: z.never().optional(),
1359
-
query: z.never().optional()
1357
+
body: z.optional(z.never()),
1358
+
path: z.optional(z.never()),
1359
+
query: z.optional(z.never())
1360
1360
});
1361
1361
1362
1362
export const zPatchApiVbyApiVersionNoTagData = z.object({
1363
-
body: z.never().optional(),
1364
-
path: z.never().optional(),
1365
-
query: z.never().optional()
1363
+
body: z.optional(z.never()),
1364
+
path: z.optional(z.never()),
1365
+
query: z.optional(z.never())
1366
1366
});
1367
1367
1368
1368
export const zImportData = z.object({
···
1370
1370
zModelWithReadOnlyAndWriteOnlyWritable,
1371
1371
zModelWithArrayReadOnlyAndWriteOnlyWritable
1372
1372
]),
1373
-
path: z.never().optional(),
1374
-
query: z.never().optional()
1373
+
path: z.optional(z.never()),
1374
+
query: z.optional(z.never())
1375
1375
});
1376
1376
1377
1377
export const zImportResponse = z.union([
···
1380
1380
]);
1381
1381
1382
1382
export const zFooWowData = z.object({
1383
-
body: z.never().optional(),
1384
-
path: z.never().optional(),
1385
-
query: z.never().optional()
1383
+
body: z.optional(z.never()),
1384
+
path: z.optional(z.never()),
1385
+
query: z.optional(z.never())
1386
1386
});
1387
1387
1388
1388
export const zApiVVersionODataControllerCountData = z.object({
1389
-
body: z.never().optional(),
1390
-
path: z.never().optional(),
1391
-
query: z.never().optional()
1389
+
body: z.optional(z.never()),
1390
+
path: z.optional(z.never()),
1391
+
query: z.optional(z.never())
1392
1392
});
1393
1393
1394
1394
/**
···
1397
1397
export const zApiVVersionODataControllerCountResponse = zModelFromZendesk;
1398
1398
1399
1399
export const zGetApiVbyApiVersionSimpleOperationData = z.object({
1400
-
body: z.never().optional(),
1400
+
body: z.optional(z.never()),
1401
1401
path: z.object({
1402
1402
foo_param: z.string()
1403
1403
}),
1404
-
query: z.never().optional()
1404
+
query: z.optional(z.never())
1405
1405
});
1406
1406
1407
1407
/**
···
1410
1410
export const zGetApiVbyApiVersionSimpleOperationResponse = z.number();
1411
1411
1412
1412
export const zDeleteCallWithoutParametersAndResponseData = z.object({
1413
-
body: z.never().optional(),
1414
-
path: z.never().optional(),
1415
-
query: z.never().optional()
1413
+
body: z.optional(z.never()),
1414
+
path: z.optional(z.never()),
1415
+
query: z.optional(z.never())
1416
1416
});
1417
1417
1418
1418
export const zGetCallWithoutParametersAndResponseData = z.object({
1419
-
body: z.never().optional(),
1420
-
path: z.never().optional(),
1421
-
query: z.never().optional()
1419
+
body: z.optional(z.never()),
1420
+
path: z.optional(z.never()),
1421
+
query: z.optional(z.never())
1422
1422
});
1423
1423
1424
1424
export const zHeadCallWithoutParametersAndResponseData = z.object({
1425
-
body: z.never().optional(),
1426
-
path: z.never().optional(),
1427
-
query: z.never().optional()
1425
+
body: z.optional(z.never()),
1426
+
path: z.optional(z.never()),
1427
+
query: z.optional(z.never())
1428
1428
});
1429
1429
1430
1430
export const zOptionsCallWithoutParametersAndResponseData = z.object({
1431
-
body: z.never().optional(),
1432
-
path: z.never().optional(),
1433
-
query: z.never().optional()
1431
+
body: z.optional(z.never()),
1432
+
path: z.optional(z.never()),
1433
+
query: z.optional(z.never())
1434
1434
});
1435
1435
1436
1436
export const zPatchCallWithoutParametersAndResponseData = z.object({
1437
-
body: z.never().optional(),
1438
-
path: z.never().optional(),
1439
-
query: z.never().optional()
1437
+
body: z.optional(z.never()),
1438
+
path: z.optional(z.never()),
1439
+
query: z.optional(z.never())
1440
1440
});
1441
1441
1442
1442
export const zPostCallWithoutParametersAndResponseData = z.object({
1443
-
body: z.never().optional(),
1444
-
path: z.never().optional(),
1445
-
query: z.never().optional()
1443
+
body: z.optional(z.never()),
1444
+
path: z.optional(z.never()),
1445
+
query: z.optional(z.never())
1446
1446
});
1447
1447
1448
1448
export const zPutCallWithoutParametersAndResponseData = z.object({
1449
-
body: z.never().optional(),
1450
-
path: z.never().optional(),
1451
-
query: z.never().optional()
1449
+
body: z.optional(z.never()),
1450
+
path: z.optional(z.never()),
1451
+
query: z.optional(z.never())
1452
1452
});
1453
1453
1454
1454
export const zDeleteFooData3 = z.object({
1455
-
body: z.never().optional(),
1455
+
body: z.optional(z.never()),
1456
1456
path: z.object({
1457
1457
foo_param: z.string(),
1458
1458
BarParam: z.string()
1459
1459
}),
1460
-
query: z.never().optional(),
1460
+
query: z.optional(z.never()),
1461
1461
headers: z.object({
1462
1462
'x-Foo-Bar': zModelWithString
1463
1463
})
1464
1464
});
1465
1465
1466
1466
export const zCallWithDescriptionsData = z.object({
1467
-
body: z.never().optional(),
1468
-
path: z.never().optional(),
1469
-
query: z.object({
1470
-
parameterWithBreaks: z.string().optional(),
1471
-
parameterWithBackticks: z.string().optional(),
1472
-
parameterWithSlashes: z.string().optional(),
1473
-
parameterWithExpressionPlaceholders: z.string().optional(),
1474
-
parameterWithQuotes: z.string().optional(),
1475
-
parameterWithReservedCharacters: z.string().optional()
1476
-
}).optional()
1467
+
body: z.optional(z.never()),
1468
+
path: z.optional(z.never()),
1469
+
query: z.optional(z.object({
1470
+
parameterWithBreaks: z.optional(z.string()),
1471
+
parameterWithBackticks: z.optional(z.string()),
1472
+
parameterWithSlashes: z.optional(z.string()),
1473
+
parameterWithExpressionPlaceholders: z.optional(z.string()),
1474
+
parameterWithQuotes: z.optional(z.string()),
1475
+
parameterWithReservedCharacters: z.optional(z.string())
1476
+
}))
1477
1477
});
1478
1478
1479
1479
export const zDeprecatedCallData = z.object({
1480
-
body: z.never().optional(),
1481
-
path: z.never().optional(),
1482
-
query: z.never().optional(),
1480
+
body: z.optional(z.never()),
1481
+
path: z.optional(z.never()),
1482
+
query: z.optional(z.never()),
1483
1483
headers: z.object({
1484
1484
parameter: z.union([
1485
1485
zDeprecatedModel,
···
1504
1504
])
1505
1505
}),
1506
1506
query: z.object({
1507
-
foo_ref_enum: zModelWithNestedArrayEnumsDataFooWritable.optional(),
1507
+
foo_ref_enum: z.optional(zModelWithNestedArrayEnumsDataFooWritable),
1508
1508
foo_all_of_enum: zModelWithNestedArrayEnumsDataFooWritable,
1509
1509
cursor: z.union([
1510
1510
z.string(),
···
1525
1525
z.null()
1526
1526
]),
1527
1527
path: z.object({
1528
-
'parameter.path.1': z.string().optional(),
1529
-
'parameter-path-2': z.string().optional(),
1530
-
'PARAMETER-PATH-3': z.string().optional(),
1528
+
'parameter.path.1': z.optional(z.string()),
1529
+
'parameter-path-2': z.optional(z.string()),
1530
+
'PARAMETER-PATH-3': z.optional(z.string()),
1531
1531
'api-version': z.union([
1532
1532
z.string(),
1533
1533
z.null()
1534
1534
])
1535
1535
}),
1536
1536
query: z.object({
1537
-
default: z.string().optional(),
1537
+
default: z.optional(z.string()),
1538
1538
'parameter-query': z.union([
1539
1539
z.string(),
1540
1540
z.null()
···
1550
1550
1551
1551
export const zGetCallWithOptionalParamData = z.object({
1552
1552
body: zModelWithOneOfEnum,
1553
-
path: z.never().optional(),
1554
-
query: z.object({
1555
-
page: z.number().optional()
1556
-
}).optional()
1553
+
path: z.optional(z.never()),
1554
+
query: z.optional(z.object({
1555
+
page: z.optional(z.number())
1556
+
}))
1557
1557
});
1558
1558
1559
1559
export const zPostCallWithOptionalParamData = z.object({
1560
-
body: z.object({
1561
-
offset: z.union([
1560
+
body: z.optional(z.object({
1561
+
offset: z.optional(z.union([
1562
1562
z.number(),
1563
1563
z.null()
1564
-
]).optional()
1565
-
}).optional(),
1566
-
path: z.never().optional(),
1564
+
]))
1565
+
})),
1566
+
path: z.optional(z.never()),
1567
1567
query: z.object({
1568
1568
parameter: zPageable
1569
1569
})
···
1575
1575
]);
1576
1576
1577
1577
export const zPostApiVbyApiVersionRequestBodyData = z.object({
1578
-
body: zSimpleRequestBody.optional(),
1579
-
path: z.never().optional(),
1580
-
query: z.object({
1581
-
parameter: z.string().optional()
1582
-
}).optional()
1578
+
body: z.optional(zSimpleRequestBody),
1579
+
path: z.optional(z.never()),
1580
+
query: z.optional(z.object({
1581
+
parameter: z.optional(z.string())
1582
+
}))
1583
1583
});
1584
1584
1585
1585
export const zPostApiVbyApiVersionFormDataData = z.object({
1586
-
body: zSimpleFormData.optional(),
1587
-
path: z.never().optional(),
1588
-
query: z.object({
1589
-
parameter: z.string().optional()
1590
-
}).optional()
1586
+
body: z.optional(zSimpleFormData),
1587
+
path: z.optional(z.never()),
1588
+
query: z.optional(z.object({
1589
+
parameter: z.optional(z.string())
1590
+
}))
1591
1591
});
1592
1592
1593
1593
export const zCallWithDefaultParametersData = z.object({
1594
-
body: z.never().optional(),
1595
-
path: z.never().optional(),
1596
-
query: z.object({
1597
-
parameterString: z.union([
1594
+
body: z.optional(z.never()),
1595
+
path: z.optional(z.never()),
1596
+
query: z.optional(z.object({
1597
+
parameterString: z.optional(z.union([
1598
1598
z.string().default('Hello World!'),
1599
1599
z.null()
1600
-
]).optional().default('Hello World!'),
1601
-
parameterNumber: z.union([
1600
+
])).default('Hello World!'),
1601
+
parameterNumber: z.optional(z.union([
1602
1602
z.number().default(123),
1603
1603
z.null()
1604
-
]).optional().default(123),
1605
-
parameterBoolean: z.union([
1604
+
])).default(123),
1605
+
parameterBoolean: z.optional(z.union([
1606
1606
z.boolean().default(true),
1607
1607
z.null()
1608
-
]).optional().default(true),
1609
-
parameterEnum: z.enum([
1608
+
])).default(true),
1609
+
parameterEnum: z.optional(z.enum([
1610
1610
'Success',
1611
1611
'Warning',
1612
1612
'Error'
1613
-
]).optional(),
1614
-
parameterModel: z.union([
1613
+
])),
1614
+
parameterModel: z.optional(z.union([
1615
1615
zModelWithString,
1616
1616
z.null()
1617
-
]).optional()
1618
-
}).optional()
1617
+
]))
1618
+
}))
1619
1619
});
1620
1620
1621
1621
export const zCallWithDefaultOptionalParametersData = z.object({
1622
-
body: z.never().optional(),
1623
-
path: z.never().optional(),
1624
-
query: z.object({
1625
-
parameterString: z.string().optional().default('Hello World!'),
1626
-
parameterNumber: z.number().optional().default(123),
1627
-
parameterBoolean: z.boolean().optional().default(true),
1628
-
parameterEnum: z.enum([
1622
+
body: z.optional(z.never()),
1623
+
path: z.optional(z.never()),
1624
+
query: z.optional(z.object({
1625
+
parameterString: z.optional(z.string()).default('Hello World!'),
1626
+
parameterNumber: z.optional(z.number()).default(123),
1627
+
parameterBoolean: z.optional(z.boolean()).default(true),
1628
+
parameterEnum: z.optional(z.enum([
1629
1629
'Success',
1630
1630
'Warning',
1631
1631
'Error'
1632
-
]).optional(),
1633
-
parameterModel: zModelWithString.optional()
1634
-
}).optional()
1632
+
])),
1633
+
parameterModel: z.optional(zModelWithString)
1634
+
}))
1635
1635
});
1636
1636
1637
1637
export const zCallToTestOrderOfParamsData = z.object({
1638
-
body: z.never().optional(),
1639
-
path: z.never().optional(),
1638
+
body: z.optional(z.never()),
1639
+
path: z.optional(z.never()),
1640
1640
query: z.object({
1641
-
parameterOptionalStringWithDefault: z.string().optional().default('Hello World!'),
1642
-
parameterOptionalStringWithEmptyDefault: z.string().optional().default(''),
1643
-
parameterOptionalStringWithNoDefault: z.string().optional(),
1641
+
parameterOptionalStringWithDefault: z.optional(z.string()).default('Hello World!'),
1642
+
parameterOptionalStringWithEmptyDefault: z.optional(z.string()).default(''),
1643
+
parameterOptionalStringWithNoDefault: z.optional(z.string()),
1644
1644
parameterStringWithDefault: z.string().default('Hello World!'),
1645
1645
parameterStringWithEmptyDefault: z.string().default(''),
1646
1646
parameterStringWithNoDefault: z.string(),
1647
-
parameterStringNullableWithNoDefault: z.union([
1647
+
parameterStringNullableWithNoDefault: z.optional(z.union([
1648
1648
z.string(),
1649
1649
z.null()
1650
-
]).optional(),
1651
-
parameterStringNullableWithDefault: z.union([
1650
+
])),
1651
+
parameterStringNullableWithDefault: z.optional(z.union([
1652
1652
z.string(),
1653
1653
z.null()
1654
-
]).optional().default(null)
1654
+
])).default(null)
1655
1655
})
1656
1656
});
1657
1657
1658
1658
export const zDuplicateNameData = z.object({
1659
-
body: z.never().optional(),
1660
-
path: z.never().optional(),
1661
-
query: z.never().optional()
1659
+
body: z.optional(z.never()),
1660
+
path: z.optional(z.never()),
1661
+
query: z.optional(z.never())
1662
1662
});
1663
1663
1664
1664
export const zDuplicateName2Data = z.object({
1665
-
body: z.never().optional(),
1666
-
path: z.never().optional(),
1667
-
query: z.never().optional()
1665
+
body: z.optional(z.never()),
1666
+
path: z.optional(z.never()),
1667
+
query: z.optional(z.never())
1668
1668
});
1669
1669
1670
1670
export const zDuplicateName3Data = z.object({
1671
-
body: z.never().optional(),
1672
-
path: z.never().optional(),
1673
-
query: z.never().optional()
1671
+
body: z.optional(z.never()),
1672
+
path: z.optional(z.never()),
1673
+
query: z.optional(z.never())
1674
1674
});
1675
1675
1676
1676
export const zDuplicateName4Data = z.object({
1677
-
body: z.never().optional(),
1678
-
path: z.never().optional(),
1679
-
query: z.never().optional()
1677
+
body: z.optional(z.never()),
1678
+
path: z.optional(z.never()),
1679
+
query: z.optional(z.never())
1680
1680
});
1681
1681
1682
1682
export const zCallWithNoContentResponseData = z.object({
1683
-
body: z.never().optional(),
1684
-
path: z.never().optional(),
1685
-
query: z.never().optional()
1683
+
body: z.optional(z.never()),
1684
+
path: z.optional(z.never()),
1685
+
query: z.optional(z.never())
1686
1686
});
1687
1687
1688
1688
/**
···
1691
1691
export const zCallWithNoContentResponseResponse = z.void();
1692
1692
1693
1693
export const zCallWithResponseAndNoContentResponseData = z.object({
1694
-
body: z.never().optional(),
1695
-
path: z.never().optional(),
1696
-
query: z.never().optional()
1694
+
body: z.optional(z.never()),
1695
+
path: z.optional(z.never()),
1696
+
query: z.optional(z.never())
1697
1697
});
1698
1698
1699
1699
export const zCallWithResponseAndNoContentResponseResponse = z.union([
···
1702
1702
]);
1703
1703
1704
1704
export const zDummyAData = z.object({
1705
-
body: z.never().optional(),
1706
-
path: z.never().optional(),
1707
-
query: z.never().optional()
1705
+
body: z.optional(z.never()),
1706
+
path: z.optional(z.never()),
1707
+
query: z.optional(z.never())
1708
1708
});
1709
1709
1710
1710
export const zDummyAResponse = z400;
1711
1711
1712
1712
export const zDummyBData = z.object({
1713
-
body: z.never().optional(),
1714
-
path: z.never().optional(),
1715
-
query: z.never().optional()
1713
+
body: z.optional(z.never()),
1714
+
path: z.optional(z.never()),
1715
+
query: z.optional(z.never())
1716
1716
});
1717
1717
1718
1718
/**
···
1721
1721
export const zDummyBResponse = z.void();
1722
1722
1723
1723
export const zCallWithResponseData = z.object({
1724
-
body: z.never().optional(),
1725
-
path: z.never().optional(),
1726
-
query: z.never().optional()
1724
+
body: z.optional(z.never()),
1725
+
path: z.optional(z.never()),
1726
+
query: z.optional(z.never())
1727
1727
});
1728
1728
1729
1729
export const zCallWithResponseResponse = zImport;
1730
1730
1731
1731
export const zCallWithDuplicateResponsesData = z.object({
1732
-
body: z.never().optional(),
1733
-
path: z.never().optional(),
1734
-
query: z.never().optional()
1732
+
body: z.optional(z.never()),
1733
+
path: z.optional(z.never()),
1734
+
query: z.optional(z.never())
1735
1735
});
1736
1736
1737
1737
export const zCallWithDuplicateResponsesResponse = z.union([
···
1740
1740
]);
1741
1741
1742
1742
export const zCallWithResponsesData = z.object({
1743
-
body: z.never().optional(),
1744
-
path: z.never().optional(),
1745
-
query: z.never().optional()
1743
+
body: z.optional(z.never()),
1744
+
path: z.optional(z.never()),
1745
+
query: z.optional(z.never())
1746
1746
});
1747
1747
1748
1748
export const zCallWithResponsesResponse = z.union([
1749
1749
z.object({
1750
-
'@namespace.string': z.string().readonly().optional(),
1751
-
'@namespace.integer': z.number().int().readonly().optional(),
1752
-
value: z.array(zModelWithString).readonly().optional()
1750
+
'@namespace.string': z.optional(z.string().readonly()),
1751
+
'@namespace.integer': z.optional(z.int().readonly()),
1752
+
value: z.optional(z.array(zModelWithString).readonly())
1753
1753
}),
1754
1754
zModelThatExtends,
1755
1755
zModelThatExtendsExtends
1756
1756
]);
1757
1757
1758
1758
export const zCollectionFormatData = z.object({
1759
-
body: z.never().optional(),
1760
-
path: z.never().optional(),
1759
+
body: z.optional(z.never()),
1760
+
path: z.optional(z.never()),
1761
1761
query: z.object({
1762
1762
parameterArrayCSV: z.union([
1763
1763
z.array(z.string()),
···
1783
1783
});
1784
1784
1785
1785
export const zTypesData = z.object({
1786
-
body: z.never().optional(),
1787
-
path: z.object({
1788
-
id: z.number().int().optional()
1789
-
}).optional(),
1786
+
body: z.optional(z.never()),
1787
+
path: z.optional(z.object({
1788
+
id: z.optional(z.int())
1789
+
})),
1790
1790
query: z.object({
1791
1791
parameterNumber: z.number().default(123),
1792
1792
parameterString: z.union([
···
1832
1832
z.null()
1833
1833
])
1834
1834
}),
1835
-
query: z.never().optional()
1835
+
query: z.optional(z.never())
1836
1836
});
1837
1837
1838
1838
export const zUploadFileResponse = z.boolean();
1839
1839
1840
1840
export const zFileResponseData = z.object({
1841
-
body: z.never().optional(),
1841
+
body: z.optional(z.never()),
1842
1842
path: z.object({
1843
1843
id: z.string(),
1844
1844
'api-version': z.string()
1845
1845
}),
1846
-
query: z.never().optional()
1846
+
query: z.optional(z.never())
1847
1847
});
1848
1848
1849
1849
/**
···
1852
1852
export const zFileResponseResponse = z.string();
1853
1853
1854
1854
export const zComplexTypesData = z.object({
1855
-
body: z.never().optional(),
1856
-
path: z.never().optional(),
1855
+
body: z.optional(z.never()),
1856
+
path: z.optional(z.never()),
1857
1857
query: z.object({
1858
1858
parameterObject: z.object({
1859
-
first: z.object({
1860
-
second: z.object({
1861
-
third: z.string().optional()
1862
-
}).optional()
1863
-
}).optional()
1859
+
first: z.optional(z.object({
1860
+
second: z.optional(z.object({
1861
+
third: z.optional(z.string())
1862
+
}))
1863
+
}))
1864
1864
}),
1865
1865
parameterReference: zModelWithString
1866
1866
})
···
1872
1872
export const zComplexTypesResponse = z.array(zModelWithString);
1873
1873
1874
1874
export const zMultipartResponseData = z.object({
1875
-
body: z.never().optional(),
1876
-
path: z.never().optional(),
1877
-
query: z.never().optional()
1875
+
body: z.optional(z.never()),
1876
+
path: z.optional(z.never()),
1877
+
query: z.optional(z.never())
1878
1878
});
1879
1879
1880
1880
/**
1881
1881
* OK
1882
1882
*/
1883
1883
export const zMultipartResponseResponse = z.object({
1884
-
file: z.string().optional(),
1885
-
metadata: z.object({
1886
-
foo: z.string().optional(),
1887
-
bar: z.string().optional()
1888
-
}).optional()
1884
+
file: z.optional(z.string()),
1885
+
metadata: z.optional(z.object({
1886
+
foo: z.optional(z.string()),
1887
+
bar: z.optional(z.string())
1888
+
}))
1889
1889
});
1890
1890
1891
1891
export const zMultipartRequestData = z.object({
1892
-
body: z.object({
1893
-
content: z.string().optional(),
1894
-
data: z.union([
1892
+
body: z.optional(z.object({
1893
+
content: z.optional(z.string()),
1894
+
data: z.optional(z.union([
1895
1895
zModelWithString,
1896
1896
z.null()
1897
-
]).optional()
1898
-
}).optional(),
1899
-
path: z.never().optional(),
1900
-
query: z.never().optional()
1897
+
]))
1898
+
})),
1899
+
path: z.optional(z.never()),
1900
+
query: z.optional(z.never())
1901
1901
});
1902
1902
1903
1903
export const zComplexParamsData = z.object({
1904
-
body: z.object({
1904
+
body: z.optional(z.object({
1905
1905
key: z.union([
1906
1906
z.string().max(64).regex(/^[a-zA-Z0-9_]*$/).readonly(),
1907
1907
z.null()
···
1910
1910
z.string().max(255),
1911
1911
z.null()
1912
1912
]),
1913
-
enabled: z.boolean().optional().default(true),
1913
+
enabled: z.optional(z.boolean()).default(true),
1914
1914
type: z.enum([
1915
1915
'Monkey',
1916
1916
'Horse',
1917
1917
'Bird'
1918
1918
]),
1919
-
listOfModels: z.union([
1919
+
listOfModels: z.optional(z.union([
1920
1920
z.array(zModelWithString),
1921
1921
z.null()
1922
-
]).optional(),
1923
-
listOfStrings: z.union([
1922
+
])),
1923
+
listOfStrings: z.optional(z.union([
1924
1924
z.array(z.string()),
1925
1925
z.null()
1926
-
]).optional(),
1926
+
])),
1927
1927
parameters: z.union([
1928
1928
zModelWithString,
1929
1929
zModelWithEnum,
1930
1930
zModelWithArray,
1931
1931
zModelWithDictionary
1932
1932
]),
1933
-
user: z.object({
1934
-
id: z.number().int().readonly().optional(),
1935
-
name: z.union([
1933
+
user: z.optional(z.object({
1934
+
id: z.optional(z.int().readonly()),
1935
+
name: z.optional(z.union([
1936
1936
z.string().readonly(),
1937
1937
z.null()
1938
-
]).readonly().optional()
1939
-
}).readonly().optional()
1940
-
}).optional(),
1938
+
]).readonly())
1939
+
}).readonly())
1940
+
})),
1941
1941
path: z.object({
1942
-
id: z.number().int(),
1942
+
id: z.int(),
1943
1943
'api-version': z.string()
1944
1944
}),
1945
-
query: z.never().optional()
1945
+
query: z.optional(z.never())
1946
1946
});
1947
1947
1948
1948
/**
···
1951
1951
export const zComplexParamsResponse = zModelWithString;
1952
1952
1953
1953
export const zCallWithResultFromHeaderData = z.object({
1954
-
body: z.never().optional(),
1955
-
path: z.never().optional(),
1956
-
query: z.never().optional()
1954
+
body: z.optional(z.never()),
1955
+
path: z.optional(z.never()),
1956
+
query: z.optional(z.never())
1957
1957
});
1958
1958
1959
1959
export const zTestErrorCodeData = z.object({
1960
-
body: z.never().optional(),
1961
-
path: z.never().optional(),
1960
+
body: z.optional(z.never()),
1961
+
path: z.optional(z.never()),
1962
1962
query: z.object({
1963
-
status: z.number().int()
1963
+
status: z.int()
1964
1964
})
1965
1965
});
1966
1966
1967
1967
export const zNonAsciiæøåÆøÅöôêÊ字符串Data = z.object({
1968
-
body: z.never().optional(),
1969
-
path: z.never().optional(),
1968
+
body: z.optional(z.never()),
1969
+
path: z.optional(z.never()),
1970
1970
query: z.object({
1971
-
'nonAsciiParamæøåÆØÅöôêÊ': z.number().int()
1971
+
'nonAsciiParamæøåÆØÅöôêÊ': z.int()
1972
1972
})
1973
1973
});
1974
1974
···
1979
1979
1980
1980
export const zPutWithFormUrlEncodedData = z.object({
1981
1981
body: zArrayWithStringsWritable,
1982
-
path: z.never().optional(),
1983
-
query: z.never().optional()
1982
+
path: z.optional(z.never()),
1983
+
query: z.optional(z.never())
1984
1984
});
+9
-9
packages/openapi-ts-tests/test/__snapshots__/3.0.x/validators/zod.gen.ts
+9
-9
packages/openapi-ts-tests/test/__snapshots__/3.0.x/validators/zod.gen.ts
···
2
2
3
3
import { z } from 'zod';
4
4
5
-
export const zBar: z.AnyZodObject = z.object({
6
-
foo: z.lazy(() => {
5
+
export const zBar = z.object({
6
+
foo: z.optional(z.lazy(() => {
7
7
return zFoo;
8
-
}).optional()
8
+
}))
9
9
});
10
10
11
-
export const zFoo: z.ZodTypeAny = z.union([
11
+
export const zFoo = z.union([
12
12
z.object({
13
-
foo: z.string().regex(/^\d{3}-\d{2}-\d{4}$/).optional(),
14
-
bar: zBar.optional(),
15
-
baz: z.array(z.lazy(() => {
13
+
foo: z.optional(z.string().regex(/^\d{3}-\d{2}-\d{4}$/)),
14
+
bar: z.optional(zBar),
15
+
baz: z.optional(z.array(z.lazy(() => {
16
16
return zFoo;
17
-
})).optional(),
18
-
qux: z.number().int().gt(0).optional().default(0)
17
+
}))),
18
+
qux: z.optional(z.int().gt(0)).default(0)
19
19
}),
20
20
z.null()
21
21
]).default(null);
+1
-1
packages/openapi-ts-tests/test/__snapshots__/3.1.x/array-items-one-of-length-1/zod.gen.ts
+1
-1
packages/openapi-ts-tests/test/__snapshots__/3.1.x/array-items-one-of-length-1/zod.gen.ts
+5
-5
packages/openapi-ts-tests/test/__snapshots__/3.1.x/plugins/@hey-api/transformers/type-format-zod/zod.gen.ts
+5
-5
packages/openapi-ts-tests/test/__snapshots__/3.1.x/plugins/@hey-api/transformers/type-format-zod/zod.gen.ts
···
3
3
import { z } from 'zod';
4
4
5
5
export const zFoo = z.object({
6
-
bar: z.number().int().optional(),
6
+
bar: z.optional(z.int()),
7
7
foo: z.coerce.bigint().default(BigInt(0)),
8
8
id: z.string()
9
9
});
10
10
11
11
export const zBar = z.object({
12
-
foo: z.number().int()
12
+
foo: z.int()
13
13
});
14
14
15
15
export const zPostFooData = z.object({
16
-
body: z.never().optional(),
17
-
path: z.never().optional(),
18
-
query: z.never().optional()
16
+
body: z.optional(z.never()),
17
+
path: z.optional(z.never()),
18
+
query: z.optional(z.never())
19
19
});
20
20
21
21
/**
+404
-404
packages/openapi-ts-tests/test/__snapshots__/3.1.x/plugins/zod/default/zod.gen.ts
+404
-404
packages/openapi-ts-tests/test/__snapshots__/3.1.x/plugins/zod/default/zod.gen.ts
···
13
13
*
14
14
* Fourth line
15
15
*/
16
-
export const zCamelCaseCommentWithBreaks = z.number().int();
16
+
export const zCamelCaseCommentWithBreaks = z.int();
17
17
18
18
/**
19
19
* Testing multiline comments in string: First line
···
21
21
*
22
22
* Fourth line
23
23
*/
24
-
export const zCommentWithBreaks = z.number().int();
24
+
export const zCommentWithBreaks = z.int();
25
25
26
26
/**
27
27
* Testing backticks in string: `backticks` and ```multiple backticks``` should work
28
28
*/
29
-
export const zCommentWithBackticks = z.number().int();
29
+
export const zCommentWithBackticks = z.int();
30
30
31
31
/**
32
32
* Testing backticks and quotes in string: `backticks`, 'quotes', "double quotes" and ```multiple backticks``` should work
33
33
*/
34
-
export const zCommentWithBackticksAndQuotes = z.number().int();
34
+
export const zCommentWithBackticksAndQuotes = z.int();
35
35
36
36
/**
37
37
* Testing slashes in string: \backwards\\\ and /forwards/// should work
38
38
*/
39
-
export const zCommentWithSlashes = z.number().int();
39
+
export const zCommentWithSlashes = z.int();
40
40
41
41
/**
42
42
* Testing expression placeholders in string: ${expression} should work
43
43
*/
44
-
export const zCommentWithExpressionPlaceholders = z.number().int();
44
+
export const zCommentWithExpressionPlaceholders = z.int();
45
45
46
46
/**
47
47
* Testing quotes in string: 'single quote''' and "double quotes""" should work
48
48
*/
49
-
export const zCommentWithQuotes = z.number().int();
49
+
export const zCommentWithQuotes = z.int();
50
50
51
51
/**
52
52
* Testing reserved characters in string: * inline * and ** inline ** should work
53
53
*/
54
-
export const zCommentWithReservedCharacters = z.number().int();
54
+
export const zCommentWithReservedCharacters = z.int();
55
55
56
56
/**
57
57
* This is a simple number
58
58
*/
59
-
export const zSimpleInteger = z.number().int();
59
+
export const zSimpleInteger = z.int();
60
60
61
61
/**
62
62
* This is a simple boolean
···
82
82
* This is a model with one string property
83
83
*/
84
84
export const zModelWithString = z.object({
85
-
prop: z.string().optional()
85
+
prop: z.optional(z.string())
86
86
});
87
87
88
88
/**
···
137
137
/**
138
138
* This is a simple array with numbers
139
139
*/
140
-
export const zArrayWithNumbers = z.array(z.number().int());
140
+
export const zArrayWithNumbers = z.array(z.int());
141
141
142
142
/**
143
143
* This is a simple array with booleans
···
163
163
* This is a simple array with properties
164
164
*/
165
165
export const zArrayWithProperties = z.array(z.object({
166
-
'16x16': zCamelCaseCommentWithBreaks.optional(),
167
-
bar: z.string().optional()
166
+
'16x16': z.optional(zCamelCaseCommentWithBreaks),
167
+
bar: z.optional(z.string())
168
168
}));
169
169
170
170
/**
···
172
172
*/
173
173
export const zArrayWithAnyOfProperties = z.array(z.union([
174
174
z.object({
175
-
foo: z.string().optional().default('test')
175
+
foo: z.optional(z.string()).default('test')
176
176
}),
177
177
z.object({
178
-
bar: z.string().optional()
178
+
bar: z.optional(z.string())
179
179
})
180
180
]));
181
181
182
182
export const zAnyOfAnyAndNull = z.object({
183
-
data: z.union([
183
+
data: z.optional(z.union([
184
184
z.unknown(),
185
185
z.null()
186
-
]).optional()
186
+
]))
187
187
});
188
188
189
189
/**
190
190
* This is a simple array with any of properties
191
191
*/
192
192
export const zAnyOfArrays = z.object({
193
-
results: z.array(z.union([
193
+
results: z.optional(z.array(z.union([
194
194
z.object({
195
-
foo: z.string().optional()
195
+
foo: z.optional(z.string())
196
196
}),
197
197
z.object({
198
-
bar: z.string().optional()
198
+
bar: z.optional(z.string())
199
199
})
200
-
])).optional()
200
+
])))
201
201
});
202
202
203
203
/**
···
206
206
export const zDictionaryWithString = z.object({});
207
207
208
208
export const zDictionaryWithPropertiesAndAdditionalProperties = z.object({
209
-
foo: z.number().optional(),
210
-
bar: z.boolean().optional()
209
+
foo: z.optional(z.number()),
210
+
bar: z.optional(z.boolean())
211
211
});
212
212
213
213
/**
···
223
223
/**
224
224
* This is a string dictionary
225
225
*/
226
-
export const zDictionaryWithDictionary = z.record(z.object({}));
226
+
export const zDictionaryWithDictionary = z.record(z.string(), z.object({}));
227
227
228
228
/**
229
229
* This is a complex dictionary
230
230
*/
231
-
export const zDictionaryWithProperties = z.record(z.object({
232
-
foo: z.string().optional(),
233
-
bar: z.string().optional()
231
+
export const zDictionaryWithProperties = z.record(z.string(), z.object({
232
+
foo: z.optional(z.string()),
233
+
bar: z.optional(z.string())
234
234
}));
235
235
236
236
/**
237
237
* This is a model with one number property
238
238
*/
239
239
export const zModelWithInteger = z.object({
240
-
prop: z.number().int().optional()
240
+
prop: z.optional(z.int())
241
241
});
242
242
243
243
/**
244
244
* This is a model with one boolean property
245
245
*/
246
246
export const zModelWithBoolean = z.object({
247
-
prop: z.boolean().optional()
247
+
prop: z.optional(z.boolean())
248
248
});
249
249
250
250
/**
251
251
* This is a model with one string property
252
252
*/
253
253
export const zModelWithStringError = z.object({
254
-
prop: z.string().optional()
254
+
prop: z.optional(z.string())
255
255
});
256
256
257
257
/**
···
263
263
* This is a model with one string property
264
264
*/
265
265
export const zModelWithNullableString = z.object({
266
-
nullableProp1: z.union([
266
+
nullableProp1: z.optional(z.union([
267
267
z.string(),
268
268
z.null()
269
-
]).optional(),
269
+
])),
270
270
nullableRequiredProp1: z.union([
271
271
z.string(),
272
272
z.null()
273
273
]),
274
-
nullableProp2: z.union([
274
+
nullableProp2: z.optional(z.union([
275
275
z.string(),
276
276
z.null()
277
-
]).optional(),
277
+
])),
278
278
nullableRequiredProp2: z.union([
279
279
z.string(),
280
280
z.null()
281
281
]),
282
-
'foo_bar-enum': z.enum([
282
+
'foo_bar-enum': z.optional(z.enum([
283
283
'Success',
284
284
'Warning',
285
285
'Error',
286
286
'ØÆÅ字符串'
287
-
]).optional()
287
+
]))
288
288
});
289
289
290
290
/**
291
291
* This is a model with one enum
292
292
*/
293
293
export const zModelWithEnum = z.object({
294
-
'foo_bar-enum': z.enum([
294
+
'foo_bar-enum': z.optional(z.enum([
295
295
'Success',
296
296
'Warning',
297
297
'Error',
298
298
'ØÆÅ字符串'
299
-
]).optional(),
300
-
statusCode: z.enum([
299
+
])),
300
+
statusCode: z.optional(z.enum([
301
301
'100',
302
302
'200 FOO',
303
303
'300 FOO_BAR',
304
304
'400 foo-bar',
305
305
'500 foo.bar',
306
306
'600 foo&bar'
307
-
]).optional(),
308
-
bool: z.unknown().optional()
307
+
])),
308
+
bool: z.optional(z.unknown())
309
309
});
310
310
311
311
/**
312
312
* This is a model with one enum with escaped name
313
313
*/
314
314
export const zModelWithEnumWithHyphen = z.object({
315
-
'foo-bar-baz-qux': z.enum([
315
+
'foo-bar-baz-qux': z.optional(z.enum([
316
316
'3.0'
317
-
]).optional()
317
+
]))
318
318
});
319
319
320
320
/**
321
321
* This is a model with one enum
322
322
*/
323
323
export const zModelWithEnumFromDescription = z.object({
324
-
test: z.number().int().optional()
324
+
test: z.optional(z.int())
325
325
});
326
326
327
327
/**
328
328
* This is a model with nested enums
329
329
*/
330
330
export const zModelWithNestedEnums = z.object({
331
-
dictionaryWithEnum: z.object({}).optional(),
332
-
dictionaryWithEnumFromDescription: z.object({}).optional(),
333
-
arrayWithEnum: z.array(z.enum([
331
+
dictionaryWithEnum: z.optional(z.object({})),
332
+
dictionaryWithEnumFromDescription: z.optional(z.object({})),
333
+
arrayWithEnum: z.optional(z.array(z.enum([
334
334
'Success',
335
335
'Warning',
336
336
'Error'
337
-
])).optional(),
338
-
arrayWithDescription: z.array(z.number().int()).optional(),
339
-
'foo_bar-enum': z.enum([
337
+
]))),
338
+
arrayWithDescription: z.optional(z.array(z.int())),
339
+
'foo_bar-enum': z.optional(z.enum([
340
340
'Success',
341
341
'Warning',
342
342
'Error',
343
343
'ØÆÅ字符串'
344
-
]).optional()
344
+
]))
345
345
});
346
346
347
347
/**
···
354
354
z.string(),
355
355
z.null()
356
356
]),
357
-
string: z.string().optional(),
358
-
number: z.number().optional(),
359
-
boolean: z.boolean().optional(),
360
-
reference: zModelWithString.optional(),
361
-
'property with space': z.string().optional(),
362
-
default: z.string().optional(),
363
-
try: z.string().optional(),
364
-
'@namespace.string': z.string().readonly().optional(),
365
-
'@namespace.integer': z.number().int().readonly().optional()
357
+
string: z.optional(z.string()),
358
+
number: z.optional(z.number()),
359
+
boolean: z.optional(z.boolean()),
360
+
reference: z.optional(zModelWithString),
361
+
'property with space': z.optional(z.string()),
362
+
default: z.optional(z.string()),
363
+
try: z.optional(z.string()),
364
+
'@namespace.string': z.optional(z.string().readonly()),
365
+
'@namespace.integer': z.optional(z.int().readonly())
366
366
});
367
367
368
368
/**
369
369
* This is a model with one property containing a reference
370
370
*/
371
371
export const zModelWithReference = z.object({
372
-
prop: zModelWithProperties.optional()
372
+
prop: z.optional(zModelWithProperties)
373
373
});
374
374
375
375
export const zModelWithReadOnlyAndWriteOnly = z.object({
···
381
381
* This is a model with one property containing an array
382
382
*/
383
383
export const zModelWithArrayReadOnlyAndWriteOnly = z.object({
384
-
prop: z.array(zModelWithReadOnlyAndWriteOnly).optional(),
385
-
propWithFile: z.array(z.string()).optional(),
386
-
propWithNumber: z.array(z.number()).optional()
384
+
prop: z.optional(z.array(zModelWithReadOnlyAndWriteOnly)),
385
+
propWithFile: z.optional(z.array(z.string())),
386
+
propWithNumber: z.optional(z.array(z.number()))
387
387
});
388
388
389
389
/**
390
390
* This is a model with one property containing an array
391
391
*/
392
392
export const zModelWithArray = z.object({
393
-
prop: z.array(zModelWithString).optional(),
394
-
propWithFile: z.array(z.string()).optional(),
395
-
propWithNumber: z.array(z.number()).optional()
393
+
prop: z.optional(z.array(zModelWithString)),
394
+
propWithFile: z.optional(z.array(z.string())),
395
+
propWithNumber: z.optional(z.array(z.number()))
396
396
});
397
397
398
398
/**
399
399
* This is a model with one property containing a dictionary
400
400
*/
401
401
export const zModelWithDictionary = z.object({
402
-
prop: z.object({}).optional()
402
+
prop: z.optional(z.object({}))
403
403
});
404
404
405
405
/**
···
407
407
* @deprecated
408
408
*/
409
409
export const zDeprecatedModel = z.object({
410
-
prop: z.string().optional()
410
+
prop: z.optional(z.string())
411
411
});
412
412
413
413
/**
414
414
* This is a model with one property containing a circular reference
415
415
*/
416
-
export const zModelWithCircularReference: z.AnyZodObject = z.object({
417
-
prop: z.lazy(() => {
416
+
export const zModelWithCircularReference = z.object({
417
+
prop: z.optional(z.lazy(() => {
418
418
return zModelWithCircularReference;
419
-
}).optional()
419
+
}))
420
420
});
421
421
422
422
/**
423
423
* This is a model with one property with a 'one of' relationship
424
424
*/
425
425
export const zCompositionWithOneOf = z.object({
426
-
propA: z.union([
426
+
propA: z.optional(z.union([
427
427
zModelWithString,
428
428
zModelWithEnum,
429
429
zModelWithArray,
430
430
zModelWithDictionary
431
-
]).optional()
431
+
]))
432
432
});
433
433
434
434
/**
435
435
* This is a model with one property with a 'one of' relationship where the options are not $ref
436
436
*/
437
437
export const zCompositionWithOneOfAnonymous = z.object({
438
-
propA: z.union([
438
+
propA: z.optional(z.union([
439
439
z.object({
440
-
propA: z.string().optional()
440
+
propA: z.optional(z.string())
441
441
}),
442
442
z.string(),
443
-
z.number().int()
444
-
]).optional()
443
+
z.int()
444
+
]))
445
445
});
446
446
447
447
/**
···
449
449
*/
450
450
export const zModelCircle = z.object({
451
451
kind: z.string(),
452
-
radius: z.number().optional()
452
+
radius: z.optional(z.number())
453
453
});
454
454
455
455
/**
···
457
457
*/
458
458
export const zModelSquare = z.object({
459
459
kind: z.string(),
460
-
sideLength: z.number().optional()
460
+
sideLength: z.optional(z.number())
461
461
});
462
462
463
463
/**
···
476
476
* This is a model with one property with a 'any of' relationship
477
477
*/
478
478
export const zCompositionWithAnyOf = z.object({
479
-
propA: z.union([
479
+
propA: z.optional(z.union([
480
480
zModelWithString,
481
481
zModelWithEnum,
482
482
zModelWithArray,
483
483
zModelWithDictionary
484
-
]).optional()
484
+
]))
485
485
});
486
486
487
487
/**
488
488
* This is a model with one property with a 'any of' relationship where the options are not $ref
489
489
*/
490
490
export const zCompositionWithAnyOfAnonymous = z.object({
491
-
propA: z.union([
491
+
propA: z.optional(z.union([
492
492
z.object({
493
-
propA: z.string().optional()
493
+
propA: z.optional(z.string())
494
494
}),
495
495
z.string(),
496
-
z.number().int()
497
-
]).optional()
496
+
z.int()
497
+
]))
498
498
});
499
499
500
500
/**
501
501
* This is a model with nested 'any of' property with a type null
502
502
*/
503
503
export const zCompositionWithNestedAnyAndTypeNull = z.object({
504
-
propA: z.union([
504
+
propA: z.optional(z.union([
505
505
z.array(z.union([
506
506
zModelWithDictionary,
507
507
z.null()
···
510
510
zModelWithArray,
511
511
z.null()
512
512
]))
513
-
]).optional()
513
+
]))
514
514
});
515
515
516
516
export const z3eNum1Период = z.enum([
···
524
524
* This is a model with one property with a 'any of' relationship where the options are not $ref
525
525
*/
526
526
export const zCompositionWithNestedAnyOfAndNull = z.object({
527
-
propA: z.union([
527
+
propA: z.optional(z.union([
528
528
z.array(z.union([
529
529
z3eNum1Период,
530
530
zConstValue
531
531
])),
532
532
z.null()
533
-
]).optional()
533
+
]))
534
534
});
535
535
536
536
/**
537
537
* This is a model with one property with a 'one of' relationship
538
538
*/
539
539
export const zCompositionWithOneOfAndNullable = z.object({
540
-
propA: z.union([
540
+
propA: z.optional(z.union([
541
541
z.object({
542
-
boolean: z.boolean().optional()
542
+
boolean: z.optional(z.boolean())
543
543
}),
544
544
zModelWithEnum,
545
545
zModelWithArray,
546
546
zModelWithDictionary,
547
547
z.null()
548
-
]).optional()
548
+
]))
549
549
});
550
550
551
551
/**
552
552
* This is a model that contains a simple dictionary within composition
553
553
*/
554
554
export const zCompositionWithOneOfAndSimpleDictionary = z.object({
555
-
propA: z.union([
555
+
propA: z.optional(z.union([
556
556
z.boolean(),
557
557
z.object({})
558
-
]).optional()
558
+
]))
559
559
});
560
560
561
561
/**
562
562
* This is a model that contains a dictionary of simple arrays within composition
563
563
*/
564
564
export const zCompositionWithOneOfAndSimpleArrayDictionary = z.object({
565
-
propA: z.union([
565
+
propA: z.optional(z.union([
566
566
z.boolean(),
567
567
z.object({})
568
-
]).optional()
568
+
]))
569
569
});
570
570
571
571
/**
572
572
* This is a model that contains a dictionary of complex arrays (composited) within composition
573
573
*/
574
574
export const zCompositionWithOneOfAndComplexArrayDictionary = z.object({
575
-
propA: z.union([
575
+
propA: z.optional(z.union([
576
576
z.boolean(),
577
577
z.object({})
578
-
]).optional()
578
+
]))
579
579
});
580
580
581
581
/**
582
582
* This is a model with one property with a 'all of' relationship
583
583
*/
584
584
export const zCompositionWithAllOfAndNullable = z.object({
585
-
propA: z.union([
585
+
propA: z.optional(z.union([
586
586
z.object({
587
-
boolean: z.boolean().optional()
587
+
boolean: z.optional(z.boolean())
588
588
}).and(zModelWithEnum).and(zModelWithArray).and(zModelWithDictionary),
589
589
z.null()
590
-
]).optional()
590
+
]))
591
591
});
592
592
593
593
/**
594
594
* This is a model with one property with a 'any of' relationship
595
595
*/
596
596
export const zCompositionWithAnyOfAndNullable = z.object({
597
-
propA: z.union([
597
+
propA: z.optional(z.union([
598
598
z.object({
599
-
boolean: z.boolean().optional()
599
+
boolean: z.optional(z.boolean())
600
600
}),
601
601
zModelWithEnum,
602
602
zModelWithArray,
603
603
zModelWithDictionary,
604
604
z.null()
605
-
]).optional()
605
+
]))
606
606
});
607
607
608
608
/**
609
609
* This is a base model with two simple optional properties
610
610
*/
611
611
export const zCompositionBaseModel = z.object({
612
-
firstName: z.string().optional(),
613
-
lastname: z.string().optional()
612
+
firstName: z.optional(z.string()),
613
+
lastname: z.optional(z.string())
614
614
});
615
615
616
616
/**
···
646
646
* This is a model with duplicated properties
647
647
*/
648
648
export const zModelWithDuplicateProperties = z.object({
649
-
prop: zModelWithString.optional()
649
+
prop: z.optional(zModelWithString)
650
650
});
651
651
652
652
/**
653
653
* This is a model with ordered properties
654
654
*/
655
655
export const zModelWithOrderedProperties = z.object({
656
-
zebra: z.string().optional(),
657
-
apple: z.string().optional(),
658
-
hawaii: z.string().optional()
656
+
zebra: z.optional(z.string()),
657
+
apple: z.optional(z.string()),
658
+
hawaii: z.optional(z.string())
659
659
});
660
660
661
661
/**
662
662
* This is a model with duplicated imports
663
663
*/
664
664
export const zModelWithDuplicateImports = z.object({
665
-
propA: zModelWithString.optional(),
666
-
propB: zModelWithString.optional(),
667
-
propC: zModelWithString.optional()
665
+
propA: z.optional(zModelWithString),
666
+
propB: z.optional(zModelWithString),
667
+
propC: z.optional(zModelWithString)
668
668
});
669
669
670
670
/**
671
671
* This is a model that extends another model
672
672
*/
673
673
export const zModelThatExtends = zModelWithString.and(z.object({
674
-
propExtendsA: z.string().optional(),
675
-
propExtendsB: zModelWithString.optional()
674
+
propExtendsA: z.optional(z.string()),
675
+
propExtendsB: z.optional(zModelWithString)
676
676
}));
677
677
678
678
/**
679
679
* This is a model that extends another model
680
680
*/
681
681
export const zModelThatExtendsExtends = zModelWithString.and(zModelThatExtends).and(z.object({
682
-
propExtendsC: z.string().optional(),
683
-
propExtendsD: zModelWithString.optional()
682
+
propExtendsC: z.optional(z.string()),
683
+
propExtendsD: z.optional(zModelWithString)
684
684
}));
685
685
686
686
/**
···
689
689
export const zModelWithPattern = z.object({
690
690
key: z.string().max(64).regex(/^[a-zA-Z0-9_]*$/),
691
691
name: z.string().max(255),
692
-
enabled: z.boolean().readonly().optional(),
693
-
modified: z.string().datetime().readonly().optional(),
694
-
id: z.string().regex(/^\d{2}-\d{3}-\d{4}$/).optional(),
695
-
text: z.string().regex(/^\w+$/).optional(),
696
-
patternWithSingleQuotes: z.string().regex(/^[a-zA-Z0-9']*$/).optional(),
697
-
patternWithNewline: z.string().regex(/aaa\nbbb/).optional(),
698
-
patternWithBacktick: z.string().regex(/aaa`bbb/).optional()
692
+
enabled: z.optional(z.boolean().readonly()),
693
+
modified: z.optional(z.iso.datetime().readonly()),
694
+
id: z.optional(z.string().regex(/^\d{2}-\d{3}-\d{4}$/)),
695
+
text: z.optional(z.string().regex(/^\w+$/)),
696
+
patternWithSingleQuotes: z.optional(z.string().regex(/^[a-zA-Z0-9']*$/)),
697
+
patternWithNewline: z.optional(z.string().regex(/aaa\nbbb/)),
698
+
patternWithBacktick: z.optional(z.string().regex(/aaa`bbb/))
699
699
});
700
700
701
701
export const zFile = z.object({
702
-
id: z.string().min(1).readonly().optional(),
703
-
updated_at: z.string().datetime().readonly().optional(),
704
-
created_at: z.string().datetime().readonly().optional(),
702
+
id: z.optional(z.string().min(1).readonly()),
703
+
updated_at: z.optional(z.iso.datetime().readonly()),
704
+
created_at: z.optional(z.iso.datetime().readonly()),
705
705
mime: z.string().min(1).max(24),
706
-
file: z.string().url().readonly().optional()
706
+
file: z.optional(z.url().readonly())
707
707
});
708
708
709
709
export const zDefault = z.object({
710
-
name: z.string().optional()
710
+
name: z.optional(z.string())
711
711
});
712
712
713
713
export const zPageable = z.object({
714
-
page: z.number().int().gte(0).optional().default(0),
715
-
size: z.number().int().gte(1).optional(),
716
-
sort: z.array(z.string()).optional()
714
+
page: z.optional(z.int().gte(0)).default(0),
715
+
size: z.optional(z.int().gte(1)),
716
+
sort: z.optional(z.array(z.string()))
717
717
});
718
718
719
719
/**
···
732
732
export const zFreeFormObjectWithAdditionalPropertiesEqEmptyObject = z.object({});
733
733
734
734
export const zModelWithConst = z.object({
735
-
String: z.literal('String').optional(),
736
-
number: z.literal(0).optional(),
737
-
null: z.null().optional(),
738
-
withType: z.literal('Some string').optional()
735
+
String: z.optional(z.literal('String')),
736
+
number: z.optional(z.literal(0)),
737
+
null: z.optional(z.null()),
738
+
withType: z.optional(z.literal('Some string'))
739
739
});
740
740
741
741
/**
742
742
* This is a model with one property and additionalProperties: true
743
743
*/
744
744
export const zModelWithAdditionalPropertiesEqTrue = z.object({
745
-
prop: z.string().optional()
745
+
prop: z.optional(z.string())
746
746
});
747
747
748
748
export const zNestedAnyOfArraysNullable = z.object({
749
-
nullableArray: z.union([
749
+
nullableArray: z.optional(z.union([
750
750
z.array(z.union([
751
751
z.string(),
752
752
z.boolean()
753
753
])),
754
754
z.null()
755
-
]).optional()
755
+
]))
756
756
});
757
757
758
758
/**
···
769
769
})
770
770
]), z.object({
771
771
baz: z.union([
772
-
z.number().int().gte(0),
772
+
z.int().gte(0),
773
773
z.null()
774
774
]),
775
-
qux: z.number().int().gte(0)
775
+
qux: z.int().gte(0)
776
776
}));
777
777
778
778
/**
···
780
780
*/
781
781
export const zNullableObject = z.union([
782
782
z.object({
783
-
foo: z.string().optional()
783
+
foo: z.optional(z.string())
784
784
}),
785
785
z.null()
786
786
]).default(null);
···
791
791
export const zCharactersInDescription = z.string();
792
792
793
793
export const zModelWithNullableObject = z.object({
794
-
data: zNullableObject.optional()
794
+
data: z.optional(zNullableObject)
795
795
});
796
796
797
797
export const zModelWithOneOfEnum = z.union([
···
811
811
])
812
812
}),
813
813
z.object({
814
-
content: z.string().datetime(),
814
+
content: z.iso.datetime(),
815
815
foo: z.enum([
816
816
'Quux'
817
817
])
818
818
}),
819
819
z.object({
820
820
content: z.tuple([
821
-
z.string().datetime(),
821
+
z.iso.datetime(),
822
822
z.string()
823
823
]),
824
824
foo: z.enum([
···
838
838
]);
839
839
840
840
export const zModelWithNestedArrayEnumsData = z.object({
841
-
foo: z.array(zModelWithNestedArrayEnumsDataFoo).optional(),
842
-
bar: z.array(zModelWithNestedArrayEnumsDataBar).optional()
841
+
foo: z.optional(z.array(zModelWithNestedArrayEnumsDataFoo)),
842
+
bar: z.optional(z.array(zModelWithNestedArrayEnumsDataBar))
843
843
});
844
844
845
845
export const zModelWithNestedArrayEnums = z.object({
846
-
array_strings: z.array(z.string()).optional(),
847
-
data: zModelWithNestedArrayEnumsData.optional()
846
+
array_strings: z.optional(z.array(z.string())),
847
+
data: z.optional(zModelWithNestedArrayEnumsData)
848
848
});
849
849
850
850
export const zModelWithNestedCompositionEnums = z.object({
851
-
foo: zModelWithNestedArrayEnumsDataFoo.optional()
851
+
foo: z.optional(zModelWithNestedArrayEnumsDataFoo)
852
852
});
853
853
854
854
export const zModelWithConstantSizeArray = z.tuple([
···
920
920
]);
921
921
922
922
export const zModelWithNumericEnumUnion = z.object({
923
-
value: z.unknown().optional()
923
+
value: z.optional(z.unknown())
924
924
});
925
925
926
926
/**
927
927
* Some description with `back ticks`
928
928
*/
929
929
export const zModelWithBackticksInDescription = z.object({
930
-
template: z.string().optional()
930
+
template: z.optional(z.string())
931
931
});
932
932
933
933
export const zModelWithOneOfAndProperties = z.intersection(z.union([
···
935
935
zNonAsciiStringæøåÆøÅöôêÊ字符串
936
936
]), z.object({
937
937
baz: z.union([
938
-
z.number().int().gte(0),
938
+
z.int().gte(0),
939
939
z.null()
940
940
]),
941
-
qux: z.number().int().gte(0)
941
+
qux: z.int().gte(0)
942
942
}));
943
943
944
944
/**
···
967
967
export const zDeleteFooData2 = z.string();
968
968
969
969
export const zSchemaWithFormRestrictedKeys = z.object({
970
-
description: z.string().optional(),
971
-
'x-enum-descriptions': z.string().optional(),
972
-
'x-enum-varnames': z.string().optional(),
973
-
'x-enumNames': z.string().optional(),
974
-
title: z.string().optional(),
975
-
object: z.object({
976
-
description: z.string().optional(),
977
-
'x-enum-descriptions': z.string().optional(),
978
-
'x-enum-varnames': z.string().optional(),
979
-
'x-enumNames': z.string().optional(),
980
-
title: z.string().optional()
981
-
}).optional(),
982
-
array: z.array(z.object({
983
-
description: z.string().optional(),
984
-
'x-enum-descriptions': z.string().optional(),
985
-
'x-enum-varnames': z.string().optional(),
986
-
'x-enumNames': z.string().optional(),
987
-
title: z.string().optional()
988
-
})).optional()
970
+
description: z.optional(z.string()),
971
+
'x-enum-descriptions': z.optional(z.string()),
972
+
'x-enum-varnames': z.optional(z.string()),
973
+
'x-enumNames': z.optional(z.string()),
974
+
title: z.optional(z.string()),
975
+
object: z.optional(z.object({
976
+
description: z.optional(z.string()),
977
+
'x-enum-descriptions': z.optional(z.string()),
978
+
'x-enum-varnames': z.optional(z.string()),
979
+
'x-enumNames': z.optional(z.string()),
980
+
title: z.optional(z.string())
981
+
})),
982
+
array: z.optional(z.array(z.object({
983
+
description: z.optional(z.string()),
984
+
'x-enum-descriptions': z.optional(z.string()),
985
+
'x-enum-varnames': z.optional(z.string()),
986
+
'x-enumNames': z.optional(z.string()),
987
+
title: z.optional(z.string())
988
+
})))
989
989
});
990
990
991
991
/**
992
992
* This schema was giving PascalCase transformations a hard time
993
993
*/
994
994
export const zIoK8sApimachineryPkgApisMetaV1Preconditions = z.object({
995
-
resourceVersion: z.string().optional(),
996
-
uid: z.string().optional()
995
+
resourceVersion: z.optional(z.string()),
996
+
uid: z.optional(z.string())
997
997
});
998
998
999
999
/**
1000
1000
* This schema was giving PascalCase transformations a hard time
1001
1001
*/
1002
1002
export const zIoK8sApimachineryPkgApisMetaV1DeleteOptions = z.object({
1003
-
preconditions: zIoK8sApimachineryPkgApisMetaV1Preconditions.optional()
1003
+
preconditions: z.optional(zIoK8sApimachineryPkgApisMetaV1Preconditions)
1004
1004
});
1005
1005
1006
1006
export const zAdditionalPropertiesUnknownIssue = z.object({});
···
1012
1012
}));
1013
1013
1014
1014
export const zAdditionalPropertiesIntegerIssue = z.object({
1015
-
value: z.number().int()
1015
+
value: z.int()
1016
1016
});
1017
1017
1018
1018
export const zGenericSchemaDuplicateIssue1SystemBoolean = z.object({
1019
-
item: z.boolean().optional(),
1020
-
error: z.union([
1019
+
item: z.optional(z.boolean()),
1020
+
error: z.optional(z.union([
1021
1021
z.string(),
1022
1022
z.null()
1023
-
]).optional(),
1024
-
hasError: z.boolean().readonly().optional(),
1025
-
data: z.object({}).optional()
1023
+
])),
1024
+
hasError: z.optional(z.boolean().readonly()),
1025
+
data: z.optional(z.object({}))
1026
1026
});
1027
1027
1028
1028
export const zGenericSchemaDuplicateIssue1SystemString = z.object({
1029
-
item: z.union([
1029
+
item: z.optional(z.union([
1030
1030
z.string(),
1031
1031
z.null()
1032
-
]).optional(),
1033
-
error: z.union([
1032
+
])),
1033
+
error: z.optional(z.union([
1034
1034
z.string(),
1035
1035
z.null()
1036
-
]).optional(),
1037
-
hasError: z.boolean().readonly().optional()
1036
+
])),
1037
+
hasError: z.optional(z.boolean().readonly())
1038
1038
});
1039
1039
1040
1040
export const zOneOfAllOfIssue = z.union([
···
1056
1056
*
1057
1057
* Fourth line
1058
1058
*/
1059
-
export const zCamelCaseCommentWithBreaksWritable = z.number().int();
1059
+
export const zCamelCaseCommentWithBreaksWritable = z.int();
1060
1060
1061
1061
/**
1062
1062
* Testing multiline comments in string: First line
···
1064
1064
*
1065
1065
* Fourth line
1066
1066
*/
1067
-
export const zCommentWithBreaksWritable = z.number().int();
1067
+
export const zCommentWithBreaksWritable = z.int();
1068
1068
1069
1069
/**
1070
1070
* Testing backticks in string: `backticks` and ```multiple backticks``` should work
1071
1071
*/
1072
-
export const zCommentWithBackticksWritable = z.number().int();
1072
+
export const zCommentWithBackticksWritable = z.int();
1073
1073
1074
1074
/**
1075
1075
* Testing backticks and quotes in string: `backticks`, 'quotes', "double quotes" and ```multiple backticks``` should work
1076
1076
*/
1077
-
export const zCommentWithBackticksAndQuotesWritable = z.number().int();
1077
+
export const zCommentWithBackticksAndQuotesWritable = z.int();
1078
1078
1079
1079
/**
1080
1080
* Testing slashes in string: \backwards\\\ and /forwards/// should work
1081
1081
*/
1082
-
export const zCommentWithSlashesWritable = z.number().int();
1082
+
export const zCommentWithSlashesWritable = z.int();
1083
1083
1084
1084
/**
1085
1085
* Testing expression placeholders in string: ${expression} should work
1086
1086
*/
1087
-
export const zCommentWithExpressionPlaceholdersWritable = z.number().int();
1087
+
export const zCommentWithExpressionPlaceholdersWritable = z.int();
1088
1088
1089
1089
/**
1090
1090
* Testing quotes in string: 'single quote''' and "double quotes""" should work
1091
1091
*/
1092
-
export const zCommentWithQuotesWritable = z.number().int();
1092
+
export const zCommentWithQuotesWritable = z.int();
1093
1093
1094
1094
/**
1095
1095
* Testing reserved characters in string: * inline * and ** inline ** should work
1096
1096
*/
1097
-
export const zCommentWithReservedCharactersWritable = z.number().int();
1097
+
export const zCommentWithReservedCharactersWritable = z.int();
1098
1098
1099
1099
/**
1100
1100
* This is a simple number
1101
1101
*/
1102
-
export const zSimpleIntegerWritable = z.number().int();
1102
+
export const zSimpleIntegerWritable = z.int();
1103
1103
1104
1104
/**
1105
1105
* This is a simple boolean
···
1168
1168
/**
1169
1169
* This is a simple array with numbers
1170
1170
*/
1171
-
export const zArrayWithNumbersWritable = z.array(z.number().int());
1171
+
export const zArrayWithNumbersWritable = z.array(z.int());
1172
1172
1173
1173
/**
1174
1174
* This is a simple array with booleans
···
1188
1188
/**
1189
1189
* This is a string dictionary
1190
1190
*/
1191
-
export const zDictionaryWithDictionaryWritable = z.record(z.object({}));
1191
+
export const zDictionaryWithDictionaryWritable = z.record(z.string(), z.object({}));
1192
1192
1193
1193
/**
1194
1194
* `Comment` or `VoiceComment`. The JSON object for adding voice comments to tickets is different. See [Adding voice comments to tickets](/documentation/ticketing/managing-tickets/adding-voice-comments-to-tickets)
···
1204
1204
* This is a model with one property containing an array
1205
1205
*/
1206
1206
export const zModelWithArrayReadOnlyAndWriteOnlyWritable = z.object({
1207
-
prop: z.array(zModelWithReadOnlyAndWriteOnlyWritable).optional(),
1208
-
propWithFile: z.array(z.string()).optional(),
1209
-
propWithNumber: z.array(z.number()).optional()
1207
+
prop: z.optional(z.array(zModelWithReadOnlyAndWriteOnlyWritable)),
1208
+
propWithFile: z.optional(z.array(z.string())),
1209
+
propWithNumber: z.optional(z.array(z.number()))
1210
1210
});
1211
1211
1212
1212
export const z3eNum1ПериодWritable = z.enum([
···
1358
1358
export const zSimpleFormData = zModelWithString;
1359
1359
1360
1360
export const zExportData = z.object({
1361
-
body: z.never().optional(),
1362
-
path: z.never().optional(),
1363
-
query: z.never().optional()
1361
+
body: z.optional(z.never()),
1362
+
path: z.optional(z.never()),
1363
+
query: z.optional(z.never())
1364
1364
});
1365
1365
1366
1366
export const zPatchApiVbyApiVersionNoTagData = z.object({
1367
-
body: z.never().optional(),
1368
-
path: z.never().optional(),
1369
-
query: z.never().optional()
1367
+
body: z.optional(z.never()),
1368
+
path: z.optional(z.never()),
1369
+
query: z.optional(z.never())
1370
1370
});
1371
1371
1372
1372
export const zImportData = z.object({
···
1374
1374
zModelWithReadOnlyAndWriteOnlyWritable,
1375
1375
zModelWithArrayReadOnlyAndWriteOnlyWritable
1376
1376
]),
1377
-
path: z.never().optional(),
1378
-
query: z.never().optional()
1377
+
path: z.optional(z.never()),
1378
+
query: z.optional(z.never())
1379
1379
});
1380
1380
1381
1381
export const zImportResponse = z.union([
···
1384
1384
]);
1385
1385
1386
1386
export const zFooWowData = z.object({
1387
-
body: z.never().optional(),
1388
-
path: z.never().optional(),
1389
-
query: z.never().optional()
1387
+
body: z.optional(z.never()),
1388
+
path: z.optional(z.never()),
1389
+
query: z.optional(z.never())
1390
1390
});
1391
1391
1392
1392
export const zApiVVersionODataControllerCountData = z.object({
1393
-
body: z.never().optional(),
1394
-
path: z.never().optional(),
1395
-
query: z.never().optional()
1393
+
body: z.optional(z.never()),
1394
+
path: z.optional(z.never()),
1395
+
query: z.optional(z.never())
1396
1396
});
1397
1397
1398
1398
/**
···
1401
1401
export const zApiVVersionODataControllerCountResponse = zModelFromZendesk;
1402
1402
1403
1403
export const zGetApiVbyApiVersionSimpleOperationData = z.object({
1404
-
body: z.never().optional(),
1404
+
body: z.optional(z.never()),
1405
1405
path: z.object({
1406
1406
foo_param: z.union([
1407
1407
z.string(),
1408
-
z.string().uuid()
1408
+
z.uuid()
1409
1409
])
1410
1410
}),
1411
-
query: z.never().optional()
1411
+
query: z.optional(z.never())
1412
1412
});
1413
1413
1414
1414
/**
···
1417
1417
export const zGetApiVbyApiVersionSimpleOperationResponse = z.number();
1418
1418
1419
1419
export const zDeleteCallWithoutParametersAndResponseData = z.object({
1420
-
body: z.never().optional(),
1421
-
path: z.never().optional(),
1422
-
query: z.never().optional()
1420
+
body: z.optional(z.never()),
1421
+
path: z.optional(z.never()),
1422
+
query: z.optional(z.never())
1423
1423
});
1424
1424
1425
1425
export const zGetCallWithoutParametersAndResponseData = z.object({
1426
-
body: z.never().optional(),
1427
-
path: z.never().optional(),
1428
-
query: z.never().optional()
1426
+
body: z.optional(z.never()),
1427
+
path: z.optional(z.never()),
1428
+
query: z.optional(z.never())
1429
1429
});
1430
1430
1431
1431
export const zHeadCallWithoutParametersAndResponseData = z.object({
1432
-
body: z.never().optional(),
1433
-
path: z.never().optional(),
1434
-
query: z.never().optional()
1432
+
body: z.optional(z.never()),
1433
+
path: z.optional(z.never()),
1434
+
query: z.optional(z.never())
1435
1435
});
1436
1436
1437
1437
export const zOptionsCallWithoutParametersAndResponseData = z.object({
1438
-
body: z.never().optional(),
1439
-
path: z.never().optional(),
1440
-
query: z.never().optional()
1438
+
body: z.optional(z.never()),
1439
+
path: z.optional(z.never()),
1440
+
query: z.optional(z.never())
1441
1441
});
1442
1442
1443
1443
export const zPatchCallWithoutParametersAndResponseData = z.object({
1444
-
body: z.never().optional(),
1445
-
path: z.never().optional(),
1446
-
query: z.never().optional()
1444
+
body: z.optional(z.never()),
1445
+
path: z.optional(z.never()),
1446
+
query: z.optional(z.never())
1447
1447
});
1448
1448
1449
1449
export const zPostCallWithoutParametersAndResponseData = z.object({
1450
-
body: z.never().optional(),
1451
-
path: z.never().optional(),
1452
-
query: z.never().optional()
1450
+
body: z.optional(z.never()),
1451
+
path: z.optional(z.never()),
1452
+
query: z.optional(z.never())
1453
1453
});
1454
1454
1455
1455
export const zPutCallWithoutParametersAndResponseData = z.object({
1456
-
body: z.never().optional(),
1457
-
path: z.never().optional(),
1458
-
query: z.never().optional()
1456
+
body: z.optional(z.never()),
1457
+
path: z.optional(z.never()),
1458
+
query: z.optional(z.never())
1459
1459
});
1460
1460
1461
1461
export const zDeleteFooData3 = z.object({
1462
-
body: z.never().optional(),
1462
+
body: z.optional(z.never()),
1463
1463
path: z.object({
1464
1464
foo_param: z.string(),
1465
1465
BarParam: z.string()
1466
1466
}),
1467
-
query: z.never().optional(),
1467
+
query: z.optional(z.never()),
1468
1468
headers: z.object({
1469
1469
'x-Foo-Bar': zModelWithString
1470
1470
})
1471
1471
});
1472
1472
1473
1473
export const zCallWithDescriptionsData = z.object({
1474
-
body: z.never().optional(),
1475
-
path: z.never().optional(),
1476
-
query: z.object({
1477
-
parameterWithBreaks: z.string().optional(),
1478
-
parameterWithBackticks: z.string().optional(),
1479
-
parameterWithSlashes: z.string().optional(),
1480
-
parameterWithExpressionPlaceholders: z.string().optional(),
1481
-
parameterWithQuotes: z.string().optional(),
1482
-
parameterWithReservedCharacters: z.string().optional()
1483
-
}).optional()
1474
+
body: z.optional(z.never()),
1475
+
path: z.optional(z.never()),
1476
+
query: z.optional(z.object({
1477
+
parameterWithBreaks: z.optional(z.string()),
1478
+
parameterWithBackticks: z.optional(z.string()),
1479
+
parameterWithSlashes: z.optional(z.string()),
1480
+
parameterWithExpressionPlaceholders: z.optional(z.string()),
1481
+
parameterWithQuotes: z.optional(z.string()),
1482
+
parameterWithReservedCharacters: z.optional(z.string())
1483
+
}))
1484
1484
});
1485
1485
1486
1486
export const zDeprecatedCallData = z.object({
1487
-
body: z.never().optional(),
1488
-
path: z.never().optional(),
1489
-
query: z.never().optional(),
1487
+
body: z.optional(z.never()),
1488
+
path: z.optional(z.never()),
1489
+
query: z.optional(z.never()),
1490
1490
headers: z.object({
1491
1491
parameter: z.union([
1492
1492
zDeprecatedModel,
···
1511
1511
])
1512
1512
}),
1513
1513
query: z.object({
1514
-
foo_ref_enum: zModelWithNestedArrayEnumsDataFooWritable.optional(),
1514
+
foo_ref_enum: z.optional(zModelWithNestedArrayEnumsDataFooWritable),
1515
1515
foo_all_of_enum: zModelWithNestedArrayEnumsDataFooWritable,
1516
1516
cursor: z.union([
1517
1517
z.string(),
···
1532
1532
z.null()
1533
1533
]),
1534
1534
path: z.object({
1535
-
'parameter.path.1': z.string().optional(),
1536
-
'parameter-path-2': z.string().optional(),
1537
-
'PARAMETER-PATH-3': z.string().optional(),
1535
+
'parameter.path.1': z.optional(z.string()),
1536
+
'parameter-path-2': z.optional(z.string()),
1537
+
'PARAMETER-PATH-3': z.optional(z.string()),
1538
1538
'api-version': z.union([
1539
1539
z.string(),
1540
1540
z.null()
1541
1541
])
1542
1542
}),
1543
1543
query: z.object({
1544
-
default: z.string().optional(),
1544
+
default: z.optional(z.string()),
1545
1545
'parameter-query': z.union([
1546
1546
z.string(),
1547
1547
z.null()
···
1557
1557
1558
1558
export const zGetCallWithOptionalParamData = z.object({
1559
1559
body: zModelWithOneOfEnum,
1560
-
path: z.never().optional(),
1561
-
query: z.object({
1562
-
page: z.number().optional()
1563
-
}).optional()
1560
+
path: z.optional(z.never()),
1561
+
query: z.optional(z.object({
1562
+
page: z.optional(z.number())
1563
+
}))
1564
1564
});
1565
1565
1566
1566
export const zPostCallWithOptionalParamData = z.object({
1567
-
body: z.object({
1568
-
offset: z.union([
1567
+
body: z.optional(z.object({
1568
+
offset: z.optional(z.union([
1569
1569
z.number(),
1570
1570
z.null()
1571
-
]).optional()
1572
-
}).optional(),
1573
-
path: z.never().optional(),
1571
+
]))
1572
+
})),
1573
+
path: z.optional(z.never()),
1574
1574
query: z.object({
1575
1575
parameter: zPageable
1576
1576
})
···
1582
1582
]);
1583
1583
1584
1584
export const zPostApiVbyApiVersionRequestBodyData = z.object({
1585
-
body: zSimpleRequestBody.optional(),
1586
-
path: z.never().optional(),
1587
-
query: z.object({
1588
-
parameter: z.string().optional()
1589
-
}).optional()
1585
+
body: z.optional(zSimpleRequestBody),
1586
+
path: z.optional(z.never()),
1587
+
query: z.optional(z.object({
1588
+
parameter: z.optional(z.string())
1589
+
}))
1590
1590
});
1591
1591
1592
1592
export const zPostApiVbyApiVersionFormDataData = z.object({
1593
-
body: zSimpleFormData.optional(),
1594
-
path: z.never().optional(),
1595
-
query: z.object({
1596
-
parameter: z.string().optional()
1597
-
}).optional()
1593
+
body: z.optional(zSimpleFormData),
1594
+
path: z.optional(z.never()),
1595
+
query: z.optional(z.object({
1596
+
parameter: z.optional(z.string())
1597
+
}))
1598
1598
});
1599
1599
1600
1600
export const zCallWithDefaultParametersData = z.object({
1601
-
body: z.never().optional(),
1602
-
path: z.never().optional(),
1603
-
query: z.object({
1604
-
parameterString: z.union([
1601
+
body: z.optional(z.never()),
1602
+
path: z.optional(z.never()),
1603
+
query: z.optional(z.object({
1604
+
parameterString: z.optional(z.union([
1605
1605
z.string().default('Hello World!'),
1606
1606
z.null()
1607
-
]).optional().default('Hello World!'),
1608
-
parameterNumber: z.union([
1607
+
])).default('Hello World!'),
1608
+
parameterNumber: z.optional(z.union([
1609
1609
z.number().default(123),
1610
1610
z.null()
1611
-
]).optional().default(123),
1612
-
parameterBoolean: z.union([
1611
+
])).default(123),
1612
+
parameterBoolean: z.optional(z.union([
1613
1613
z.boolean().default(true),
1614
1614
z.null()
1615
-
]).optional().default(true),
1616
-
parameterEnum: z.enum([
1615
+
])).default(true),
1616
+
parameterEnum: z.optional(z.enum([
1617
1617
'Success',
1618
1618
'Warning',
1619
1619
'Error'
1620
-
]).optional(),
1621
-
parameterModel: z.union([
1620
+
])),
1621
+
parameterModel: z.optional(z.union([
1622
1622
zModelWithString,
1623
1623
z.null()
1624
-
]).optional()
1625
-
}).optional()
1624
+
]))
1625
+
}))
1626
1626
});
1627
1627
1628
1628
export const zCallWithDefaultOptionalParametersData = z.object({
1629
-
body: z.never().optional(),
1630
-
path: z.never().optional(),
1631
-
query: z.object({
1632
-
parameterString: z.string().optional().default('Hello World!'),
1633
-
parameterNumber: z.number().optional().default(123),
1634
-
parameterBoolean: z.boolean().optional().default(true),
1635
-
parameterEnum: z.enum([
1629
+
body: z.optional(z.never()),
1630
+
path: z.optional(z.never()),
1631
+
query: z.optional(z.object({
1632
+
parameterString: z.optional(z.string()).default('Hello World!'),
1633
+
parameterNumber: z.optional(z.number()).default(123),
1634
+
parameterBoolean: z.optional(z.boolean()).default(true),
1635
+
parameterEnum: z.optional(z.enum([
1636
1636
'Success',
1637
1637
'Warning',
1638
1638
'Error'
1639
-
]).optional(),
1640
-
parameterModel: zModelWithString.optional()
1641
-
}).optional()
1639
+
])),
1640
+
parameterModel: z.optional(zModelWithString)
1641
+
}))
1642
1642
});
1643
1643
1644
1644
export const zCallToTestOrderOfParamsData = z.object({
1645
-
body: z.never().optional(),
1646
-
path: z.never().optional(),
1645
+
body: z.optional(z.never()),
1646
+
path: z.optional(z.never()),
1647
1647
query: z.object({
1648
-
parameterOptionalStringWithDefault: z.string().optional().default('Hello World!'),
1649
-
parameterOptionalStringWithEmptyDefault: z.string().optional().default(''),
1650
-
parameterOptionalStringWithNoDefault: z.string().optional(),
1648
+
parameterOptionalStringWithDefault: z.optional(z.string()).default('Hello World!'),
1649
+
parameterOptionalStringWithEmptyDefault: z.optional(z.string()).default(''),
1650
+
parameterOptionalStringWithNoDefault: z.optional(z.string()),
1651
1651
parameterStringWithDefault: z.string().default('Hello World!'),
1652
1652
parameterStringWithEmptyDefault: z.string().default(''),
1653
1653
parameterStringWithNoDefault: z.string(),
1654
-
parameterStringNullableWithNoDefault: z.union([
1654
+
parameterStringNullableWithNoDefault: z.optional(z.union([
1655
1655
z.string(),
1656
1656
z.null()
1657
-
]).optional(),
1658
-
parameterStringNullableWithDefault: z.union([
1657
+
])),
1658
+
parameterStringNullableWithDefault: z.optional(z.union([
1659
1659
z.string(),
1660
1660
z.null()
1661
-
]).optional().default(null)
1661
+
])).default(null)
1662
1662
})
1663
1663
});
1664
1664
1665
1665
export const zDuplicateNameData = z.object({
1666
-
body: z.never().optional(),
1667
-
path: z.never().optional(),
1668
-
query: z.never().optional()
1666
+
body: z.optional(z.never()),
1667
+
path: z.optional(z.never()),
1668
+
query: z.optional(z.never())
1669
1669
});
1670
1670
1671
1671
export const zDuplicateName2Data = z.object({
1672
-
body: z.never().optional(),
1673
-
path: z.never().optional(),
1674
-
query: z.never().optional()
1672
+
body: z.optional(z.never()),
1673
+
path: z.optional(z.never()),
1674
+
query: z.optional(z.never())
1675
1675
});
1676
1676
1677
1677
export const zDuplicateName3Data = z.object({
1678
-
body: z.never().optional(),
1679
-
path: z.never().optional(),
1680
-
query: z.never().optional()
1678
+
body: z.optional(z.never()),
1679
+
path: z.optional(z.never()),
1680
+
query: z.optional(z.never())
1681
1681
});
1682
1682
1683
1683
export const zDuplicateName4Data = z.object({
1684
-
body: z.never().optional(),
1685
-
path: z.never().optional(),
1686
-
query: z.never().optional()
1684
+
body: z.optional(z.never()),
1685
+
path: z.optional(z.never()),
1686
+
query: z.optional(z.never())
1687
1687
});
1688
1688
1689
1689
export const zCallWithNoContentResponseData = z.object({
1690
-
body: z.never().optional(),
1691
-
path: z.never().optional(),
1692
-
query: z.never().optional()
1690
+
body: z.optional(z.never()),
1691
+
path: z.optional(z.never()),
1692
+
query: z.optional(z.never())
1693
1693
});
1694
1694
1695
1695
/**
···
1698
1698
export const zCallWithNoContentResponseResponse = z.void();
1699
1699
1700
1700
export const zCallWithResponseAndNoContentResponseData = z.object({
1701
-
body: z.never().optional(),
1702
-
path: z.never().optional(),
1703
-
query: z.never().optional()
1701
+
body: z.optional(z.never()),
1702
+
path: z.optional(z.never()),
1703
+
query: z.optional(z.never())
1704
1704
});
1705
1705
1706
1706
export const zCallWithResponseAndNoContentResponseResponse = z.union([
···
1709
1709
]);
1710
1710
1711
1711
export const zDummyAData = z.object({
1712
-
body: z.never().optional(),
1713
-
path: z.never().optional(),
1714
-
query: z.never().optional()
1712
+
body: z.optional(z.never()),
1713
+
path: z.optional(z.never()),
1714
+
query: z.optional(z.never())
1715
1715
});
1716
1716
1717
1717
export const zDummyAResponse = z400;
1718
1718
1719
1719
export const zDummyBData = z.object({
1720
-
body: z.never().optional(),
1721
-
path: z.never().optional(),
1722
-
query: z.never().optional()
1720
+
body: z.optional(z.never()),
1721
+
path: z.optional(z.never()),
1722
+
query: z.optional(z.never())
1723
1723
});
1724
1724
1725
1725
/**
···
1728
1728
export const zDummyBResponse = z.void();
1729
1729
1730
1730
export const zCallWithResponseData = z.object({
1731
-
body: z.never().optional(),
1732
-
path: z.never().optional(),
1733
-
query: z.never().optional()
1731
+
body: z.optional(z.never()),
1732
+
path: z.optional(z.never()),
1733
+
query: z.optional(z.never())
1734
1734
});
1735
1735
1736
1736
export const zCallWithResponseResponse = zImport;
1737
1737
1738
1738
export const zCallWithDuplicateResponsesData = z.object({
1739
-
body: z.never().optional(),
1740
-
path: z.never().optional(),
1741
-
query: z.never().optional()
1739
+
body: z.optional(z.never()),
1740
+
path: z.optional(z.never()),
1741
+
query: z.optional(z.never())
1742
1742
});
1743
1743
1744
1744
export const zCallWithDuplicateResponsesResponse = z.union([
···
1747
1747
]);
1748
1748
1749
1749
export const zCallWithResponsesData = z.object({
1750
-
body: z.never().optional(),
1751
-
path: z.never().optional(),
1752
-
query: z.never().optional()
1750
+
body: z.optional(z.never()),
1751
+
path: z.optional(z.never()),
1752
+
query: z.optional(z.never())
1753
1753
});
1754
1754
1755
1755
export const zCallWithResponsesResponse = z.union([
1756
1756
z.object({
1757
-
'@namespace.string': z.string().readonly().optional(),
1758
-
'@namespace.integer': z.number().int().readonly().optional(),
1759
-
value: z.array(zModelWithString).readonly().optional()
1757
+
'@namespace.string': z.optional(z.string().readonly()),
1758
+
'@namespace.integer': z.optional(z.int().readonly()),
1759
+
value: z.optional(z.array(zModelWithString).readonly())
1760
1760
}),
1761
1761
zModelThatExtends,
1762
1762
zModelThatExtendsExtends
1763
1763
]);
1764
1764
1765
1765
export const zCollectionFormatData = z.object({
1766
-
body: z.never().optional(),
1767
-
path: z.never().optional(),
1766
+
body: z.optional(z.never()),
1767
+
path: z.optional(z.never()),
1768
1768
query: z.object({
1769
1769
parameterArrayCSV: z.union([
1770
1770
z.array(z.string()),
···
1790
1790
});
1791
1791
1792
1792
export const zTypesData = z.object({
1793
-
body: z.never().optional(),
1794
-
path: z.object({
1795
-
id: z.number().int().optional()
1796
-
}).optional(),
1793
+
body: z.optional(z.never()),
1794
+
path: z.optional(z.object({
1795
+
id: z.optional(z.int())
1796
+
})),
1797
1797
query: z.object({
1798
1798
parameterNumber: z.number().default(123),
1799
1799
parameterString: z.union([
···
1840
1840
z.null()
1841
1841
])
1842
1842
}),
1843
-
query: z.never().optional()
1843
+
query: z.optional(z.never())
1844
1844
});
1845
1845
1846
1846
export const zUploadFileResponse = z.boolean();
1847
1847
1848
1848
export const zFileResponseData = z.object({
1849
-
body: z.never().optional(),
1849
+
body: z.optional(z.never()),
1850
1850
path: z.object({
1851
1851
id: z.string(),
1852
1852
'api-version': z.string()
1853
1853
}),
1854
-
query: z.never().optional()
1854
+
query: z.optional(z.never())
1855
1855
});
1856
1856
1857
1857
/**
···
1860
1860
export const zFileResponseResponse = z.string();
1861
1861
1862
1862
export const zComplexTypesData = z.object({
1863
-
body: z.never().optional(),
1864
-
path: z.never().optional(),
1863
+
body: z.optional(z.never()),
1864
+
path: z.optional(z.never()),
1865
1865
query: z.object({
1866
1866
parameterObject: z.object({
1867
-
first: z.object({
1868
-
second: z.object({
1869
-
third: z.string().optional()
1870
-
}).optional()
1871
-
}).optional()
1867
+
first: z.optional(z.object({
1868
+
second: z.optional(z.object({
1869
+
third: z.optional(z.string())
1870
+
}))
1871
+
}))
1872
1872
}),
1873
1873
parameterReference: zModelWithString
1874
1874
})
···
1880
1880
export const zComplexTypesResponse = z.array(zModelWithString);
1881
1881
1882
1882
export const zMultipartResponseData = z.object({
1883
-
body: z.never().optional(),
1884
-
path: z.never().optional(),
1885
-
query: z.never().optional()
1883
+
body: z.optional(z.never()),
1884
+
path: z.optional(z.never()),
1885
+
query: z.optional(z.never())
1886
1886
});
1887
1887
1888
1888
/**
1889
1889
* OK
1890
1890
*/
1891
1891
export const zMultipartResponseResponse = z.object({
1892
-
file: z.string().optional(),
1893
-
metadata: z.object({
1894
-
foo: z.string().optional(),
1895
-
bar: z.string().optional()
1896
-
}).optional()
1892
+
file: z.optional(z.string()),
1893
+
metadata: z.optional(z.object({
1894
+
foo: z.optional(z.string()),
1895
+
bar: z.optional(z.string())
1896
+
}))
1897
1897
});
1898
1898
1899
1899
export const zMultipartRequestData = z.object({
1900
-
body: z.object({
1901
-
content: z.string().optional(),
1902
-
data: z.union([
1900
+
body: z.optional(z.object({
1901
+
content: z.optional(z.string()),
1902
+
data: z.optional(z.union([
1903
1903
zModelWithString,
1904
1904
z.null()
1905
-
]).optional()
1906
-
}).optional(),
1907
-
path: z.never().optional(),
1908
-
query: z.never().optional()
1905
+
]))
1906
+
})),
1907
+
path: z.optional(z.never()),
1908
+
query: z.optional(z.never())
1909
1909
});
1910
1910
1911
1911
export const zComplexParamsData = z.object({
1912
-
body: z.object({
1912
+
body: z.optional(z.object({
1913
1913
key: z.union([
1914
1914
z.string().max(64).regex(/^[a-zA-Z0-9_]*$/).readonly(),
1915
1915
z.null()
···
1918
1918
z.string().max(255),
1919
1919
z.null()
1920
1920
]),
1921
-
enabled: z.boolean().optional().default(true),
1921
+
enabled: z.optional(z.boolean()).default(true),
1922
1922
type: z.enum([
1923
1923
'Monkey',
1924
1924
'Horse',
1925
1925
'Bird'
1926
1926
]),
1927
-
listOfModels: z.union([
1927
+
listOfModels: z.optional(z.union([
1928
1928
z.array(zModelWithString),
1929
1929
z.null()
1930
-
]).optional(),
1931
-
listOfStrings: z.union([
1930
+
])),
1931
+
listOfStrings: z.optional(z.union([
1932
1932
z.array(z.string()),
1933
1933
z.null()
1934
-
]).optional(),
1934
+
])),
1935
1935
parameters: z.union([
1936
1936
zModelWithString,
1937
1937
zModelWithEnum,
1938
1938
zModelWithArray,
1939
1939
zModelWithDictionary
1940
1940
]),
1941
-
user: z.object({
1942
-
id: z.number().int().readonly().optional(),
1943
-
name: z.union([
1941
+
user: z.optional(z.object({
1942
+
id: z.optional(z.int().readonly()),
1943
+
name: z.optional(z.union([
1944
1944
z.string().readonly(),
1945
1945
z.null()
1946
-
]).readonly().optional()
1947
-
}).readonly().optional()
1948
-
}).optional(),
1946
+
]).readonly())
1947
+
}).readonly())
1948
+
})),
1949
1949
path: z.object({
1950
-
id: z.number().int(),
1950
+
id: z.int(),
1951
1951
'api-version': z.string()
1952
1952
}),
1953
-
query: z.never().optional()
1953
+
query: z.optional(z.never())
1954
1954
});
1955
1955
1956
1956
/**
···
1959
1959
export const zComplexParamsResponse = zModelWithString;
1960
1960
1961
1961
export const zCallWithResultFromHeaderData = z.object({
1962
-
body: z.never().optional(),
1963
-
path: z.never().optional(),
1964
-
query: z.never().optional()
1962
+
body: z.optional(z.never()),
1963
+
path: z.optional(z.never()),
1964
+
query: z.optional(z.never())
1965
1965
});
1966
1966
1967
1967
export const zTestErrorCodeData = z.object({
1968
-
body: z.never().optional(),
1969
-
path: z.never().optional(),
1968
+
body: z.optional(z.never()),
1969
+
path: z.optional(z.never()),
1970
1970
query: z.object({
1971
-
status: z.number().int()
1971
+
status: z.int()
1972
1972
})
1973
1973
});
1974
1974
1975
1975
export const zNonAsciiæøåÆøÅöôêÊ字符串Data = z.object({
1976
-
body: z.never().optional(),
1977
-
path: z.never().optional(),
1976
+
body: z.optional(z.never()),
1977
+
path: z.optional(z.never()),
1978
1978
query: z.object({
1979
-
'nonAsciiParamæøåÆØÅöôêÊ': z.number().int()
1979
+
'nonAsciiParamæøåÆØÅöôêÊ': z.int()
1980
1980
})
1981
1981
});
1982
1982
···
1987
1987
1988
1988
export const zPutWithFormUrlEncodedData = z.object({
1989
1989
body: zArrayWithStringsWritable,
1990
-
path: z.never().optional(),
1991
-
query: z.never().optional()
1990
+
path: z.optional(z.never()),
1991
+
query: z.optional(z.never())
1992
1992
});
+8
-8
packages/openapi-ts-tests/test/__snapshots__/3.1.x/schema-const/zod.gen.ts
+8
-8
packages/openapi-ts-tests/test/__snapshots__/3.1.x/schema-const/zod.gen.ts
···
3
3
import { z } from 'zod';
4
4
5
5
export const zFoo = z.object({
6
-
foo: z.literal('foo').optional(),
7
-
bar: z.literal(3.2).optional(),
8
-
baz: z.literal(-1).optional(),
9
-
qux: z.literal(true).optional(),
10
-
quux: z.tuple([
6
+
foo: z.optional(z.literal('foo')),
7
+
bar: z.optional(z.literal(3.2)),
8
+
baz: z.optional(z.literal(-1)),
9
+
qux: z.optional(z.literal(true)),
10
+
quux: z.optional(z.tuple([
11
11
z.literal(1),
12
12
z.literal(2),
13
13
z.literal(3),
14
14
z.literal('foo'),
15
15
z.literal(true)
16
-
]).optional(),
17
-
corge: z.object({}).optional(),
18
-
garply: z.coerce.bigint().optional()
16
+
])),
17
+
corge: z.optional(z.object({})),
18
+
garply: z.optional(z.coerce.bigint())
19
19
});
+1
-1
packages/openapi-ts-tests/test/__snapshots__/3.1.x/validators-bigint-min-max/zod.gen.ts
+1
-1
packages/openapi-ts-tests/test/__snapshots__/3.1.x/validators-bigint-min-max/zod.gen.ts
+2
-2
packages/openapi-ts-tests/test/__snapshots__/3.1.x/validators-circular-ref-2/zod.gen.ts
+2
-2
packages/openapi-ts-tests/test/__snapshots__/3.1.x/validators-circular-ref-2/zod.gen.ts
···
2
2
3
3
import { z } from 'zod';
4
4
5
-
export const zBar: z.AnyZodObject = z.object({
5
+
export const zBar = z.object({
6
6
bar: z.union([
7
7
z.array(z.lazy(() => {
8
8
return zBar;
···
11
11
])
12
12
});
13
13
14
-
export const zFoo: z.AnyZodObject = z.object({
14
+
export const zFoo = z.object({
15
15
foo: zBar
16
16
});
+7
-7
packages/openapi-ts-tests/test/__snapshots__/3.1.x/validators-circular-ref/zod.gen.ts
+7
-7
packages/openapi-ts-tests/test/__snapshots__/3.1.x/validators-circular-ref/zod.gen.ts
···
2
2
3
3
import { z } from 'zod';
4
4
5
-
export const zBar: z.AnyZodObject = z.object({
6
-
bar: z.array(z.lazy(() => {
5
+
export const zBar = z.object({
6
+
bar: z.optional(z.array(z.lazy(() => {
7
7
return zBar;
8
-
})).optional()
8
+
})))
9
9
});
10
10
11
-
export const zFoo: z.AnyZodObject = z.object({
12
-
foo: zBar.optional()
11
+
export const zFoo = z.object({
12
+
foo: z.optional(zBar)
13
13
});
14
14
15
15
/**
16
16
* description caused circular reference error
17
17
*/
18
-
export const zQux: z.ZodTypeAny = z.lazy(() => {
18
+
export const zQux = z.lazy(() => {
19
19
return zQux;
20
20
});
21
21
22
-
export const zBaz: z.ZodTypeAny = zQux;
22
+
export const zBaz = zQux;
+26
-26
packages/openapi-ts-tests/test/__snapshots__/3.1.x/validators-dates/zod.gen.ts
+26
-26
packages/openapi-ts-tests/test/__snapshots__/3.1.x/validators-dates/zod.gen.ts
···
5
5
/**
6
6
* This is Bar schema.
7
7
*/
8
-
export const zBar: z.AnyZodObject = z.object({
9
-
foo: z.lazy(() => {
8
+
export const zBar = z.object({
9
+
foo: z.optional(z.lazy(() => {
10
10
return zFoo;
11
-
}).optional()
11
+
}))
12
12
});
13
13
14
14
/**
15
15
* This is Foo schema.
16
16
*/
17
-
export const zFoo: z.ZodTypeAny = z.union([
17
+
export const zFoo = z.union([
18
18
z.object({
19
-
foo: z.string().regex(/^\d{3}-\d{2}-\d{4}$/).optional(),
20
-
bar: zBar.optional(),
21
-
baz: z.array(z.lazy(() => {
19
+
foo: z.optional(z.string().regex(/^\d{3}-\d{2}-\d{4}$/)),
20
+
bar: z.optional(zBar),
21
+
baz: z.optional(z.array(z.lazy(() => {
22
22
return zFoo;
23
-
})).optional(),
24
-
qux: z.number().int().gt(0).optional().default(0)
23
+
}))),
24
+
qux: z.optional(z.int().gt(0)).default(0)
25
25
}),
26
26
z.null()
27
27
]).default(null);
28
28
29
29
export const zBaz = z.string().regex(/foo\nbar/).readonly().default('baz');
30
30
31
-
export const zQux = z.record(z.object({
32
-
qux: z.string().optional()
31
+
export const zQux = z.record(z.string(), z.object({
32
+
qux: z.optional(z.string())
33
33
}));
34
34
35
35
/**
···
38
38
export const zFoo2 = z.string();
39
39
40
40
export const zFoo3 = z.object({
41
-
foo: zBar.optional()
41
+
foo: z.optional(zBar)
42
42
});
43
43
44
44
export const zPatchFooData = z.object({
45
45
body: z.object({
46
-
foo: z.string().optional()
46
+
foo: z.optional(z.string())
47
47
}),
48
-
path: z.never().optional(),
49
-
query: z.object({
50
-
foo: z.string().optional(),
51
-
bar: zBar.optional(),
52
-
baz: z.object({
53
-
baz: z.string().optional()
54
-
}).optional(),
55
-
qux: z.string().date().optional(),
56
-
quux: z.string().datetime({
48
+
path: z.optional(z.never()),
49
+
query: z.optional(z.object({
50
+
foo: z.optional(z.string()),
51
+
bar: z.optional(zBar),
52
+
baz: z.optional(z.object({
53
+
baz: z.optional(z.string())
54
+
})),
55
+
qux: z.optional(z.iso.date()),
56
+
quux: z.optional(z.iso.datetime({
57
57
offset: true
58
-
}).optional()
59
-
}).optional()
58
+
}))
59
+
}))
60
60
});
61
61
62
62
export const zPostFooData = z.object({
63
63
body: zFoo3,
64
-
path: z.never().optional(),
65
-
query: z.never().optional()
64
+
path: z.optional(z.never()),
65
+
query: z.optional(z.never())
66
66
});
+39
-27
packages/openapi-ts-tests/test/__snapshots__/3.1.x/validators-metadata/zod.gen.ts
+39
-27
packages/openapi-ts-tests/test/__snapshots__/3.1.x/validators-metadata/zod.gen.ts
···
5
5
/**
6
6
* This is Bar schema.
7
7
*/
8
-
export const zBar: z.AnyZodObject = z.object({
9
-
foo: z.lazy(() => {
8
+
export const zBar = z.object({
9
+
foo: z.optional(z.lazy(() => {
10
10
return zFoo;
11
-
}).optional()
12
-
}).describe('This is Bar schema.');
11
+
}))
12
+
}).register(z.globalRegistry, {
13
+
description: 'This is Bar schema.'
14
+
});
13
15
14
16
/**
15
17
* This is Foo schema.
16
18
*/
17
-
export const zFoo: z.ZodTypeAny = z.union([
19
+
export const zFoo = z.union([
18
20
z.object({
19
-
foo: z.string().regex(/^\d{3}-\d{2}-\d{4}$/).describe('This is foo property.').optional(),
20
-
bar: zBar.optional(),
21
-
baz: z.array(z.lazy(() => {
21
+
foo: z.optional(z.string().regex(/^\d{3}-\d{2}-\d{4}$/).register(z.globalRegistry, {
22
+
description: 'This is foo property.'
23
+
})),
24
+
bar: z.optional(zBar),
25
+
baz: z.optional(z.array(z.lazy(() => {
22
26
return zFoo;
23
-
})).describe('This is baz property.').optional(),
24
-
qux: z.number().int().gt(0).describe('This is qux property.').optional().default(0)
27
+
})).register(z.globalRegistry, {
28
+
description: 'This is baz property.'
29
+
})),
30
+
qux: z.optional(z.int().gt(0).register(z.globalRegistry, {
31
+
description: 'This is qux property.'
32
+
})).default(0)
25
33
}),
26
34
z.null()
27
35
]).default(null);
28
36
29
37
export const zBaz = z.string().regex(/foo\nbar/).readonly().default('baz');
30
38
31
-
export const zQux = z.record(z.object({
32
-
qux: z.string().optional()
39
+
export const zQux = z.record(z.string(), z.object({
40
+
qux: z.optional(z.string())
33
41
}));
34
42
35
43
/**
36
44
* This is Foo parameter.
37
45
*/
38
-
export const zFoo2 = z.string().describe('This is Foo parameter.');
46
+
export const zFoo2 = z.string().register(z.globalRegistry, {
47
+
description: 'This is Foo parameter.'
48
+
});
39
49
40
50
export const zFoo3 = z.object({
41
-
foo: zBar.optional()
51
+
foo: z.optional(zBar)
42
52
});
43
53
44
54
export const zPatchFooData = z.object({
45
55
body: z.object({
46
-
foo: z.string().optional()
56
+
foo: z.optional(z.string())
47
57
}),
48
-
path: z.never().optional(),
49
-
query: z.object({
50
-
foo: z.string().describe('This is Foo parameter.').optional(),
51
-
bar: zBar.optional(),
52
-
baz: z.object({
53
-
baz: z.string().optional()
54
-
}).optional(),
55
-
qux: z.string().date().optional(),
56
-
quux: z.string().datetime().optional()
57
-
}).optional()
58
+
path: z.optional(z.never()),
59
+
query: z.optional(z.object({
60
+
foo: z.optional(z.string().register(z.globalRegistry, {
61
+
description: 'This is Foo parameter.'
62
+
})),
63
+
bar: z.optional(zBar),
64
+
baz: z.optional(z.object({
65
+
baz: z.optional(z.string())
66
+
})),
67
+
qux: z.optional(z.iso.date()),
68
+
quux: z.optional(z.iso.datetime())
69
+
}))
58
70
});
59
71
60
72
export const zPostFooData = z.object({
61
73
body: zFoo3,
62
-
path: z.never().optional(),
63
-
query: z.never().optional()
74
+
path: z.optional(z.never()),
75
+
query: z.optional(z.never())
64
76
});
+25
-25
packages/openapi-ts-tests/test/__snapshots__/3.1.x/validators-types/zod.gen.ts
+25
-25
packages/openapi-ts-tests/test/__snapshots__/3.1.x/validators-types/zod.gen.ts
···
5
5
/**
6
6
* This is Bar schema.
7
7
*/
8
-
export const zBar: z.AnyZodObject = z.object({
9
-
foo: z.lazy(() => {
8
+
export const zBar = z.object({
9
+
foo: z.optional(z.lazy(() => {
10
10
return zFoo;
11
-
}).optional()
11
+
}))
12
12
});
13
13
14
14
export type BarZodType = z.infer<typeof zBar>;
···
16
16
/**
17
17
* This is Foo schema.
18
18
*/
19
-
export const zFoo: z.ZodTypeAny = z.union([
19
+
export const zFoo = z.union([
20
20
z.object({
21
-
foo: z.string().regex(/^\d{3}-\d{2}-\d{4}$/).optional(),
22
-
bar: zBar.optional(),
23
-
baz: z.array(z.lazy(() => {
21
+
foo: z.optional(z.string().regex(/^\d{3}-\d{2}-\d{4}$/)),
22
+
bar: z.optional(zBar),
23
+
baz: z.optional(z.array(z.lazy(() => {
24
24
return zFoo;
25
-
})).optional(),
26
-
qux: z.number().int().gt(0).optional().default(0)
25
+
}))),
26
+
qux: z.optional(z.int().gt(0)).default(0)
27
27
}),
28
28
z.null()
29
29
]).default(null);
···
34
34
35
35
export type BazZodType = z.infer<typeof zBaz>;
36
36
37
-
export const zQux = z.record(z.object({
38
-
qux: z.string().optional()
37
+
export const zQux = z.record(z.string(), z.object({
38
+
qux: z.optional(z.string())
39
39
}));
40
40
41
41
export type QuxZodType = z.infer<typeof zQux>;
···
48
48
export type FooZodType2 = z.infer<typeof zFoo2>;
49
49
50
50
export const zFoo3 = z.object({
51
-
foo: zBar.optional()
51
+
foo: z.optional(zBar)
52
52
});
53
53
54
54
export type FooZodType3 = z.infer<typeof zFoo3>;
55
55
56
56
export const zPatchFooData = z.object({
57
57
body: z.object({
58
-
foo: z.string().optional()
58
+
foo: z.optional(z.string())
59
59
}),
60
-
path: z.never().optional(),
61
-
query: z.object({
62
-
foo: z.string().optional(),
63
-
bar: zBar.optional(),
64
-
baz: z.object({
65
-
baz: z.string().optional()
66
-
}).optional(),
67
-
qux: z.string().date().optional(),
68
-
quux: z.string().datetime().optional()
69
-
}).optional()
60
+
path: z.optional(z.never()),
61
+
query: z.optional(z.object({
62
+
foo: z.optional(z.string()),
63
+
bar: z.optional(zBar),
64
+
baz: z.optional(z.object({
65
+
baz: z.optional(z.string())
66
+
})),
67
+
qux: z.optional(z.iso.date()),
68
+
quux: z.optional(z.iso.datetime())
69
+
}))
70
70
});
71
71
72
72
export type PatchFooDataZodType = z.infer<typeof zPatchFooData>;
73
73
74
74
export const zPostFooData = z.object({
75
75
body: zFoo3,
76
-
path: z.never().optional(),
77
-
query: z.never().optional()
76
+
path: z.optional(z.never()),
77
+
query: z.optional(z.never())
78
78
});
79
79
80
80
export type PostFooDataZodType = z.infer<typeof zPostFooData>;
+3
-3
packages/openapi-ts-tests/test/__snapshots__/3.1.x/validators-union-merge/zod.gen.ts
+3
-3
packages/openapi-ts-tests/test/__snapshots__/3.1.x/validators-union-merge/zod.gen.ts
···
17
17
18
18
export const zDogDetails = z.object({
19
19
breed: z.string(),
20
-
barkVolume: z.number().int().gte(1).lte(10)
20
+
barkVolume: z.int().gte(1).lte(10)
21
21
});
22
22
23
23
export const zCatDetails = z.object({
···
32
32
export const zPetStore = z.object({
33
33
animals: z.array(z.object({
34
34
name: z.string(),
35
-
type: z.enum([
35
+
type: z.optional(z.enum([
36
36
'dog',
37
37
'cat'
38
-
]).optional(),
38
+
])),
39
39
details: z.union([
40
40
zDogDetails,
41
41
zCatDetails
+25
-25
packages/openapi-ts-tests/test/__snapshots__/3.1.x/validators/zod.gen.ts
+25
-25
packages/openapi-ts-tests/test/__snapshots__/3.1.x/validators/zod.gen.ts
···
5
5
/**
6
6
* This is Bar schema.
7
7
*/
8
-
export const zBar: z.AnyZodObject = z.object({
9
-
foo: z.lazy(() => {
8
+
export const zBar = z.object({
9
+
foo: z.optional(z.lazy(() => {
10
10
return zFoo;
11
-
}).optional()
11
+
}))
12
12
});
13
13
14
14
/**
15
15
* This is Foo schema.
16
16
*/
17
-
export const zFoo: z.ZodTypeAny = z.union([
17
+
export const zFoo = z.union([
18
18
z.object({
19
-
foo: z.string().regex(/^\d{3}-\d{2}-\d{4}$/).optional(),
20
-
bar: zBar.optional(),
21
-
baz: z.array(z.lazy(() => {
19
+
foo: z.optional(z.string().regex(/^\d{3}-\d{2}-\d{4}$/)),
20
+
bar: z.optional(zBar),
21
+
baz: z.optional(z.array(z.lazy(() => {
22
22
return zFoo;
23
-
})).optional(),
24
-
qux: z.number().int().gt(0).optional().default(0)
23
+
}))),
24
+
qux: z.optional(z.int().gt(0)).default(0)
25
25
}),
26
26
z.null()
27
27
]).default(null);
28
28
29
29
export const zBaz = z.string().regex(/foo\nbar/).readonly().default('baz');
30
30
31
-
export const zQux = z.record(z.object({
32
-
qux: z.string().optional()
31
+
export const zQux = z.record(z.string(), z.object({
32
+
qux: z.optional(z.string())
33
33
}));
34
34
35
35
/**
···
38
38
export const zFoo2 = z.string();
39
39
40
40
export const zFoo3 = z.object({
41
-
foo: zBar.optional()
41
+
foo: z.optional(zBar)
42
42
});
43
43
44
44
export const zPatchFooData = z.object({
45
45
body: z.object({
46
-
foo: z.string().optional()
46
+
foo: z.optional(z.string())
47
47
}),
48
-
path: z.never().optional(),
49
-
query: z.object({
50
-
foo: z.string().optional(),
51
-
bar: zBar.optional(),
52
-
baz: z.object({
53
-
baz: z.string().optional()
54
-
}).optional(),
55
-
qux: z.string().date().optional(),
56
-
quux: z.string().datetime().optional()
57
-
}).optional()
48
+
path: z.optional(z.never()),
49
+
query: z.optional(z.object({
50
+
foo: z.optional(z.string()),
51
+
bar: z.optional(zBar),
52
+
baz: z.optional(z.object({
53
+
baz: z.optional(z.string())
54
+
})),
55
+
qux: z.optional(z.iso.date()),
56
+
quux: z.optional(z.iso.datetime())
57
+
}))
58
58
});
59
59
60
60
export const zPostFooData = z.object({
61
61
body: zFoo3,
62
-
path: z.never().optional(),
63
-
query: z.never().optional()
62
+
path: z.optional(z.never()),
63
+
query: z.optional(z.never())
64
64
});
+9
-9
pnpm-lock.yaml
+9
-9
pnpm-lock.yaml
···
329
329
specifier: 4.5.0
330
330
version: 4.5.0(vue@3.5.13(typescript@5.8.3))
331
331
zod:
332
-
specifier: 3.25.3
333
-
version: 3.25.3
332
+
specifier: 4.0.5
333
+
version: 4.0.5
334
334
devDependencies:
335
335
vite:
336
336
specifier: 6.2.7
···
357
357
specifier: 1.1.0
358
358
version: 1.1.0(typescript@5.8.3)
359
359
zod:
360
-
specifier: 3.25.3
361
-
version: 3.25.3
360
+
specifier: 4.0.5
361
+
version: 4.0.5
362
362
devDependencies:
363
363
'@config/vite-base':
364
364
specifier: workspace:*
···
980
980
specifier: 3.5.13
981
981
version: 3.5.13(typescript@5.8.3)
982
982
zod:
983
-
specifier: 3.25.3
984
-
version: 3.25.3
983
+
specifier: 4.0.5
984
+
version: 4.0.5
985
985
986
986
packages/vite-plugin:
987
987
devDependencies:
···
12051
12051
zod@3.23.8:
12052
12052
resolution: {integrity: sha512-XBx9AXhXktjUqnepgTiE5flcKIYWi/rme0Eaj+5Y0lftuGBq+jyRu/md4WnuxqgP1ubdpNCsYEYPxrzVHD8d6g==}
12053
12053
12054
-
zod@3.25.3:
12055
-
resolution: {integrity: sha512-VGZqnyYNrl8JpEJRZaFPqeVNIuqgXNu4cXZ5cOb6zEUO1OxKbRnWB4UdDIXMmiERWncs0yDQukssHov8JUxykQ==}
12054
+
zod@4.0.5:
12055
+
resolution: {integrity: sha512-/5UuuRPStvHXu7RS+gmvRf4NXrNxpSllGwDnCBcJZtQsKrviYXm54yDGV2KYNLT5kq0lHGcl7lqWJLgSaG+tgA==}
12056
12056
12057
12057
zone.js@0.15.0:
12058
12058
resolution: {integrity: sha512-9oxn0IIjbCZkJ67L+LkhYWRyAy7axphb3VgE2MBDlOqnmHMPWGYMxJxBYFueFq/JGY2GMwS0rU+UCLunEmy5UA==}
···
25016
25016
25017
25017
zod@3.23.8: {}
25018
25018
25019
-
zod@3.25.3: {}
25019
+
zod@4.0.5: {}
25020
25020
25021
25021
zone.js@0.15.0: {}
25022
25022