fork of hey-api/openapi-ts because I need some additional things
test(snapshots): update snapshots
+4588
-552
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/body-response-text-plain/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/body-response-text-plain/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/body-response-text-plain/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/body-response-text-plain/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/form-data/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/form-data/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/form-data/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/form-data/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@angular/common/default-class/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@angular/common/default-class/client/utils.gen.ts
···
99
99
allowReserved,
100
100
array,
101
101
object,
102
+
parameters = {},
102
103
}: QuerySerializerOptions = {}) => {
103
104
const querySerializer = (queryParams: T) => {
104
105
const search: string[] = [];
···
110
111
continue;
111
112
}
112
113
114
+
// Get parameter-specific settings or fall back to global
115
+
const paramConfig = parameters[name] || {};
116
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
117
+
113
118
if (Array.isArray(value)) {
114
119
const serializedArray = serializeArrayParam({
115
-
allowReserved,
120
+
allowReserved: paramAllowReserved,
116
121
explode: true,
117
122
name,
118
123
style: 'form',
119
124
value,
120
125
...array,
126
+
...paramConfig.array,
121
127
});
122
128
if (serializedArray) search.push(serializedArray);
123
129
} else if (typeof value === 'object') {
124
130
const serializedObject = serializeObjectParam({
125
-
allowReserved,
131
+
allowReserved: paramAllowReserved,
126
132
explode: true,
127
133
name,
128
134
style: 'deepObject',
129
135
value: value as Record<string, unknown>,
130
136
...object,
137
+
...paramConfig.object,
131
138
});
132
139
if (serializedObject) search.push(serializedObject);
133
140
} else {
134
141
const serializedPrimitive = serializePrimitiveParam({
135
-
allowReserved,
142
+
allowReserved: paramAllowReserved,
136
143
name,
137
144
value: value as string,
138
145
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@angular/common/default-class/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@angular/common/default-class/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@angular/common/default-class/sdk.gen.ts
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@angular/common/default-class/sdk.gen.ts
···
111
111
112
112
export const callWithDefaultParameters = <ThrowOnError extends boolean = false>(options: Options<CallWithDefaultParametersData, ThrowOnError>) => {
113
113
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
114
+
querySerializer: {
115
+
parameters: {
116
+
parameterModel: {
117
+
object: {
118
+
explode: false,
119
+
style: 'form'
120
+
}
121
+
}
122
+
}
123
+
},
114
124
url: '/api/v{api-version}/defaults',
115
125
...options
116
126
});
···
210
220
export const collectionFormat = <ThrowOnError extends boolean = false>(options: Options<CollectionFormatData, ThrowOnError>) => {
211
221
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
212
222
querySerializer: {
213
-
array: {
214
-
explode: false,
215
-
style: 'form'
223
+
parameters: {
224
+
parameterArrayCSV: {
225
+
array: {
226
+
explode: false,
227
+
style: 'form'
228
+
}
229
+
},
230
+
parameterArraySSV: {
231
+
array: {
232
+
explode: false,
233
+
style: 'form'
234
+
}
235
+
},
236
+
parameterArrayTSV: {
237
+
array: {
238
+
explode: false,
239
+
style: 'form'
240
+
}
241
+
},
242
+
parameterArrayPipes: {
243
+
array: {
244
+
explode: false,
245
+
style: 'form'
246
+
}
247
+
}
216
248
}
217
249
},
218
250
url: '/api/v{api-version}/collectionFormat',
···
223
255
export const types = <ThrowOnError extends boolean = false>(options: Options<TypesData, ThrowOnError>) => {
224
256
return (options.client ?? client).get<TypesResponses, unknown, ThrowOnError>({
225
257
querySerializer: {
226
-
array: {
227
-
explode: false,
228
-
style: 'form'
258
+
parameters: {
259
+
parameterArray: {
260
+
array: {
261
+
explode: false,
262
+
style: 'form'
263
+
}
264
+
},
265
+
parameterDictionary: {
266
+
object: {
267
+
explode: false,
268
+
style: 'form'
269
+
}
270
+
}
229
271
}
230
272
},
231
273
url: '/api/v{api-version}/types',
···
235
277
236
278
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
237
279
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
280
+
querySerializer: {
281
+
parameters: {
282
+
parameterObject: {
283
+
object: {
284
+
explode: false,
285
+
style: 'form'
286
+
}
287
+
},
288
+
parameterReference: {
289
+
object: {
290
+
explode: false,
291
+
style: 'form'
292
+
}
293
+
}
294
+
}
295
+
},
238
296
url: '/api/v{api-version}/complex',
239
297
...options
240
298
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@angular/common/default/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@angular/common/default/client/utils.gen.ts
···
99
99
allowReserved,
100
100
array,
101
101
object,
102
+
parameters = {},
102
103
}: QuerySerializerOptions = {}) => {
103
104
const querySerializer = (queryParams: T) => {
104
105
const search: string[] = [];
···
110
111
continue;
111
112
}
112
113
114
+
// Get parameter-specific settings or fall back to global
115
+
const paramConfig = parameters[name] || {};
116
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
117
+
113
118
if (Array.isArray(value)) {
114
119
const serializedArray = serializeArrayParam({
115
-
allowReserved,
120
+
allowReserved: paramAllowReserved,
116
121
explode: true,
117
122
name,
118
123
style: 'form',
119
124
value,
120
125
...array,
126
+
...paramConfig.array,
121
127
});
122
128
if (serializedArray) search.push(serializedArray);
123
129
} else if (typeof value === 'object') {
124
130
const serializedObject = serializeObjectParam({
125
-
allowReserved,
131
+
allowReserved: paramAllowReserved,
126
132
explode: true,
127
133
name,
128
134
style: 'deepObject',
129
135
value: value as Record<string, unknown>,
130
136
...object,
137
+
...paramConfig.object,
131
138
});
132
139
if (serializedObject) search.push(serializedObject);
133
140
} else {
134
141
const serializedPrimitive = serializePrimitiveParam({
135
-
allowReserved,
142
+
allowReserved: paramAllowReserved,
136
143
name,
137
144
value: value as string,
138
145
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@angular/common/default/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@angular/common/default/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@angular/common/default/sdk.gen.ts
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@angular/common/default/sdk.gen.ts
···
111
111
112
112
export const callWithDefaultParameters = <ThrowOnError extends boolean = false>(options: Options<CallWithDefaultParametersData, ThrowOnError>) => {
113
113
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
114
+
querySerializer: {
115
+
parameters: {
116
+
parameterModel: {
117
+
object: {
118
+
explode: false,
119
+
style: 'form'
120
+
}
121
+
}
122
+
}
123
+
},
114
124
url: '/api/v{api-version}/defaults',
115
125
...options
116
126
});
···
210
220
export const collectionFormat = <ThrowOnError extends boolean = false>(options: Options<CollectionFormatData, ThrowOnError>) => {
211
221
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
212
222
querySerializer: {
213
-
array: {
214
-
explode: false,
215
-
style: 'form'
223
+
parameters: {
224
+
parameterArrayCSV: {
225
+
array: {
226
+
explode: false,
227
+
style: 'form'
228
+
}
229
+
},
230
+
parameterArraySSV: {
231
+
array: {
232
+
explode: false,
233
+
style: 'form'
234
+
}
235
+
},
236
+
parameterArrayTSV: {
237
+
array: {
238
+
explode: false,
239
+
style: 'form'
240
+
}
241
+
},
242
+
parameterArrayPipes: {
243
+
array: {
244
+
explode: false,
245
+
style: 'form'
246
+
}
247
+
}
216
248
}
217
249
},
218
250
url: '/api/v{api-version}/collectionFormat',
···
223
255
export const types = <ThrowOnError extends boolean = false>(options: Options<TypesData, ThrowOnError>) => {
224
256
return (options.client ?? client).get<TypesResponses, unknown, ThrowOnError>({
225
257
querySerializer: {
226
-
array: {
227
-
explode: false,
228
-
style: 'form'
258
+
parameters: {
259
+
parameterArray: {
260
+
array: {
261
+
explode: false,
262
+
style: 'form'
263
+
}
264
+
},
265
+
parameterDictionary: {
266
+
object: {
267
+
explode: false,
268
+
style: 'form'
269
+
}
270
+
}
229
271
}
230
272
},
231
273
url: '/api/v{api-version}/types',
···
235
277
236
278
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
237
279
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
280
+
querySerializer: {
281
+
parameters: {
282
+
parameterObject: {
283
+
object: {
284
+
explode: false,
285
+
style: 'form'
286
+
}
287
+
},
288
+
parameterReference: {
289
+
object: {
290
+
explode: false,
291
+
style: 'form'
292
+
}
293
+
}
294
+
}
295
+
},
238
296
url: '/api/v{api-version}/complex',
239
297
...options
240
298
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/client-fetch/sdk-nested-classes-instance/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/client-fetch/sdk-nested-classes-instance/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/client-fetch/sdk-nested-classes-instance/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/client-fetch/sdk-nested-classes-instance/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/client-fetch/sdk-nested-classes/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/client-fetch/sdk-nested-classes/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/client-fetch/sdk-nested-classes/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/client-fetch/sdk-nested-classes/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/sdk/default/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/sdk/default/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/sdk/default/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/sdk/default/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/sdk/default/sdk.gen.ts
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/sdk/default/sdk.gen.ts
···
111
111
112
112
export const callWithDefaultParameters = <ThrowOnError extends boolean = false>(options: Options<CallWithDefaultParametersData, ThrowOnError>) => {
113
113
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
114
+
querySerializer: {
115
+
parameters: {
116
+
parameterModel: {
117
+
object: {
118
+
explode: false,
119
+
style: 'form'
120
+
}
121
+
}
122
+
}
123
+
},
114
124
url: '/api/v{api-version}/defaults',
115
125
...options
116
126
});
···
210
220
export const collectionFormat = <ThrowOnError extends boolean = false>(options: Options<CollectionFormatData, ThrowOnError>) => {
211
221
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
212
222
querySerializer: {
213
-
array: {
214
-
explode: false,
215
-
style: 'form'
223
+
parameters: {
224
+
parameterArrayCSV: {
225
+
array: {
226
+
explode: false,
227
+
style: 'form'
228
+
}
229
+
},
230
+
parameterArraySSV: {
231
+
array: {
232
+
explode: false,
233
+
style: 'form'
234
+
}
235
+
},
236
+
parameterArrayTSV: {
237
+
array: {
238
+
explode: false,
239
+
style: 'form'
240
+
}
241
+
},
242
+
parameterArrayPipes: {
243
+
array: {
244
+
explode: false,
245
+
style: 'form'
246
+
}
247
+
}
216
248
}
217
249
},
218
250
url: '/api/v{api-version}/collectionFormat',
···
223
255
export const types = <ThrowOnError extends boolean = false>(options: Options<TypesData, ThrowOnError>) => {
224
256
return (options.client ?? client).get<TypesResponses, unknown, ThrowOnError>({
225
257
querySerializer: {
226
-
array: {
227
-
explode: false,
228
-
style: 'form'
258
+
parameters: {
259
+
parameterArray: {
260
+
array: {
261
+
explode: false,
262
+
style: 'form'
263
+
}
264
+
},
265
+
parameterDictionary: {
266
+
object: {
267
+
explode: false,
268
+
style: 'form'
269
+
}
270
+
}
229
271
}
230
272
},
231
273
url: '/api/v{api-version}/types',
···
235
277
236
278
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
237
279
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
280
+
querySerializer: {
281
+
parameters: {
282
+
parameterObject: {
283
+
object: {
284
+
explode: false,
285
+
style: 'form'
286
+
}
287
+
},
288
+
parameterReference: {
289
+
object: {
290
+
explode: false,
291
+
style: 'form'
292
+
}
293
+
}
294
+
}
295
+
},
238
296
url: '/api/v{api-version}/complex',
239
297
...options
240
298
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/sdk/instance/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/sdk/instance/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/sdk/instance/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/sdk/instance/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/sdk/throwOnError/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/sdk/throwOnError/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/sdk/throwOnError/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/sdk/throwOnError/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/sdk/throwOnError/sdk.gen.ts
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/sdk/throwOnError/sdk.gen.ts
···
111
111
112
112
export const callWithDefaultParameters = <ThrowOnError extends boolean = true>(options: Options<CallWithDefaultParametersData, ThrowOnError>) => {
113
113
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
114
+
querySerializer: {
115
+
parameters: {
116
+
parameterModel: {
117
+
object: {
118
+
explode: false,
119
+
style: 'form'
120
+
}
121
+
}
122
+
}
123
+
},
114
124
url: '/api/v{api-version}/defaults',
115
125
...options
116
126
});
···
210
220
export const collectionFormat = <ThrowOnError extends boolean = true>(options: Options<CollectionFormatData, ThrowOnError>) => {
211
221
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
212
222
querySerializer: {
213
-
array: {
214
-
explode: false,
215
-
style: 'form'
223
+
parameters: {
224
+
parameterArrayCSV: {
225
+
array: {
226
+
explode: false,
227
+
style: 'form'
228
+
}
229
+
},
230
+
parameterArraySSV: {
231
+
array: {
232
+
explode: false,
233
+
style: 'form'
234
+
}
235
+
},
236
+
parameterArrayTSV: {
237
+
array: {
238
+
explode: false,
239
+
style: 'form'
240
+
}
241
+
},
242
+
parameterArrayPipes: {
243
+
array: {
244
+
explode: false,
245
+
style: 'form'
246
+
}
247
+
}
216
248
}
217
249
},
218
250
url: '/api/v{api-version}/collectionFormat',
···
223
255
export const types = <ThrowOnError extends boolean = true>(options: Options<TypesData, ThrowOnError>) => {
224
256
return (options.client ?? client).get<TypesResponses, unknown, ThrowOnError>({
225
257
querySerializer: {
226
-
array: {
227
-
explode: false,
228
-
style: 'form'
258
+
parameters: {
259
+
parameterArray: {
260
+
array: {
261
+
explode: false,
262
+
style: 'form'
263
+
}
264
+
},
265
+
parameterDictionary: {
266
+
object: {
267
+
explode: false,
268
+
style: 'form'
269
+
}
270
+
}
229
271
}
230
272
},
231
273
url: '/api/v{api-version}/types',
···
235
277
236
278
export const complexTypes = <ThrowOnError extends boolean = true>(options: Options<ComplexTypesData, ThrowOnError>) => {
237
279
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
280
+
querySerializer: {
281
+
parameters: {
282
+
parameterObject: {
283
+
object: {
284
+
explode: false,
285
+
style: 'form'
286
+
}
287
+
},
288
+
parameterReference: {
289
+
object: {
290
+
explode: false,
291
+
style: 'form'
292
+
}
293
+
}
294
+
}
295
+
},
238
296
url: '/api/v{api-version}/complex',
239
297
...options
240
298
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/transformers/type-format-valibot/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/transformers/type-format-valibot/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/transformers/type-format-valibot/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/transformers/type-format-valibot/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/transformers/type-format-zod/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/transformers/type-format-zod/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/transformers/type-format-zod/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/transformers/type-format-zod/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/typescript/transforms-read-write-custom-name/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/typescript/transforms-read-write-custom-name/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/typescript/transforms-read-write-custom-name/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/typescript/transforms-read-write-custom-name/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/typescript/transforms-read-write-ignore/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/typescript/transforms-read-write-ignore/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/typescript/transforms-read-write-ignore/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/typescript/transforms-read-write-ignore/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@pinia/colada/asClass/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@pinia/colada/asClass/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@pinia/colada/asClass/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@pinia/colada/asClass/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@pinia/colada/fetch/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@pinia/colada/fetch/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@pinia/colada/fetch/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@pinia/colada/fetch/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@pinia/colada/fetch/sdk.gen.ts
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@pinia/colada/fetch/sdk.gen.ts
···
111
111
112
112
export const callWithDefaultParameters = <ThrowOnError extends boolean = false>(options: Options<CallWithDefaultParametersData, ThrowOnError>) => {
113
113
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
114
+
querySerializer: {
115
+
parameters: {
116
+
parameterModel: {
117
+
object: {
118
+
explode: false,
119
+
style: 'form'
120
+
}
121
+
}
122
+
}
123
+
},
114
124
url: '/api/v{api-version}/defaults',
115
125
...options
116
126
});
···
210
220
export const collectionFormat = <ThrowOnError extends boolean = false>(options: Options<CollectionFormatData, ThrowOnError>) => {
211
221
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
212
222
querySerializer: {
213
-
array: {
214
-
explode: false,
215
-
style: 'form'
223
+
parameters: {
224
+
parameterArrayCSV: {
225
+
array: {
226
+
explode: false,
227
+
style: 'form'
228
+
}
229
+
},
230
+
parameterArraySSV: {
231
+
array: {
232
+
explode: false,
233
+
style: 'form'
234
+
}
235
+
},
236
+
parameterArrayTSV: {
237
+
array: {
238
+
explode: false,
239
+
style: 'form'
240
+
}
241
+
},
242
+
parameterArrayPipes: {
243
+
array: {
244
+
explode: false,
245
+
style: 'form'
246
+
}
247
+
}
216
248
}
217
249
},
218
250
url: '/api/v{api-version}/collectionFormat',
···
223
255
export const types = <ThrowOnError extends boolean = false>(options: Options<TypesData, ThrowOnError>) => {
224
256
return (options.client ?? client).get<TypesResponses, unknown, ThrowOnError>({
225
257
querySerializer: {
226
-
array: {
227
-
explode: false,
228
-
style: 'form'
258
+
parameters: {
259
+
parameterArray: {
260
+
array: {
261
+
explode: false,
262
+
style: 'form'
263
+
}
264
+
},
265
+
parameterDictionary: {
266
+
object: {
267
+
explode: false,
268
+
style: 'form'
269
+
}
270
+
}
229
271
}
230
272
},
231
273
url: '/api/v{api-version}/types',
···
235
277
236
278
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
237
279
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
280
+
querySerializer: {
281
+
parameters: {
282
+
parameterObject: {
283
+
object: {
284
+
explode: false,
285
+
style: 'form'
286
+
}
287
+
},
288
+
parameterReference: {
289
+
object: {
290
+
explode: false,
291
+
style: 'form'
292
+
}
293
+
}
294
+
}
295
+
},
238
296
url: '/api/v{api-version}/complex',
239
297
...options
240
298
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/asClass/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/asClass/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/asClass/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/asClass/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/axios/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/axios/client/utils.gen.ts
···
14
14
allowReserved,
15
15
array,
16
16
object,
17
+
parameters = {},
17
18
}: QuerySerializerOptions = {}) => {
18
19
const querySerializer = (queryParams: T) => {
19
20
const search: string[] = [];
···
25
26
continue;
26
27
}
27
28
29
+
// Get parameter-specific settings or fall back to global
30
+
const paramConfig = parameters[name] || {};
31
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
32
+
28
33
if (Array.isArray(value)) {
29
34
const serializedArray = serializeArrayParam({
30
-
allowReserved,
35
+
allowReserved: paramAllowReserved,
31
36
explode: true,
32
37
name,
33
38
style: 'form',
34
39
value,
35
40
...array,
41
+
...paramConfig.array,
36
42
});
37
43
if (serializedArray) search.push(serializedArray);
38
44
} else if (typeof value === 'object') {
39
45
const serializedObject = serializeObjectParam({
40
-
allowReserved,
46
+
allowReserved: paramAllowReserved,
41
47
explode: true,
42
48
name,
43
49
style: 'deepObject',
44
50
value: value as Record<string, unknown>,
45
51
...object,
52
+
...paramConfig.object,
46
53
});
47
54
if (serializedObject) search.push(serializedObject);
48
55
} else {
49
56
const serializedPrimitive = serializePrimitiveParam({
50
-
allowReserved,
57
+
allowReserved: paramAllowReserved,
51
58
name,
52
59
value: value as string,
53
60
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/axios/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/axios/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/axios/sdk.gen.ts
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/axios/sdk.gen.ts
···
111
111
112
112
export const callWithDefaultParameters = <ThrowOnError extends boolean = false>(options: Options<CallWithDefaultParametersData, ThrowOnError>) => {
113
113
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
114
+
querySerializer: {
115
+
parameters: {
116
+
parameterModel: {
117
+
object: {
118
+
explode: false,
119
+
style: 'form'
120
+
}
121
+
}
122
+
}
123
+
},
114
124
url: '/api/v{api-version}/defaults',
115
125
...options
116
126
});
···
216
226
export const collectionFormat = <ThrowOnError extends boolean = false>(options: Options<CollectionFormatData, ThrowOnError>) => {
217
227
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
218
228
querySerializer: {
219
-
array: {
220
-
explode: false,
221
-
style: 'form'
229
+
parameters: {
230
+
parameterArrayCSV: {
231
+
array: {
232
+
explode: false,
233
+
style: 'form'
234
+
}
235
+
},
236
+
parameterArraySSV: {
237
+
array: {
238
+
explode: false,
239
+
style: 'form'
240
+
}
241
+
},
242
+
parameterArrayTSV: {
243
+
array: {
244
+
explode: false,
245
+
style: 'form'
246
+
}
247
+
},
248
+
parameterArrayPipes: {
249
+
array: {
250
+
explode: false,
251
+
style: 'form'
252
+
}
253
+
}
222
254
}
223
255
},
224
256
url: '/api/v{api-version}/collectionFormat',
···
229
261
export const types = <ThrowOnError extends boolean = false>(options: Options<TypesData, ThrowOnError>) => {
230
262
return (options.client ?? client).get<TypesResponses, unknown, ThrowOnError>({
231
263
querySerializer: {
232
-
array: {
233
-
explode: false,
234
-
style: 'form'
264
+
parameters: {
265
+
parameterArray: {
266
+
array: {
267
+
explode: false,
268
+
style: 'form'
269
+
}
270
+
},
271
+
parameterDictionary: {
272
+
object: {
273
+
explode: false,
274
+
style: 'form'
275
+
}
276
+
}
235
277
}
236
278
},
237
279
responseType: 'json',
···
242
284
243
285
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
244
286
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
287
+
querySerializer: {
288
+
parameters: {
289
+
parameterObject: {
290
+
object: {
291
+
explode: false,
292
+
style: 'form'
293
+
}
294
+
},
295
+
parameterReference: {
296
+
object: {
297
+
explode: false,
298
+
style: 'form'
299
+
}
300
+
}
301
+
}
302
+
},
245
303
responseType: 'json',
246
304
url: '/api/v{api-version}/complex',
247
305
...options
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/fetch/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/fetch/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/fetch/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/fetch/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/fetch/sdk.gen.ts
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/fetch/sdk.gen.ts
···
111
111
112
112
export const callWithDefaultParameters = <ThrowOnError extends boolean = false>(options: Options<CallWithDefaultParametersData, ThrowOnError>) => {
113
113
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
114
+
querySerializer: {
115
+
parameters: {
116
+
parameterModel: {
117
+
object: {
118
+
explode: false,
119
+
style: 'form'
120
+
}
121
+
}
122
+
}
123
+
},
114
124
url: '/api/v{api-version}/defaults',
115
125
...options
116
126
});
···
210
220
export const collectionFormat = <ThrowOnError extends boolean = false>(options: Options<CollectionFormatData, ThrowOnError>) => {
211
221
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
212
222
querySerializer: {
213
-
array: {
214
-
explode: false,
215
-
style: 'form'
223
+
parameters: {
224
+
parameterArrayCSV: {
225
+
array: {
226
+
explode: false,
227
+
style: 'form'
228
+
}
229
+
},
230
+
parameterArraySSV: {
231
+
array: {
232
+
explode: false,
233
+
style: 'form'
234
+
}
235
+
},
236
+
parameterArrayTSV: {
237
+
array: {
238
+
explode: false,
239
+
style: 'form'
240
+
}
241
+
},
242
+
parameterArrayPipes: {
243
+
array: {
244
+
explode: false,
245
+
style: 'form'
246
+
}
247
+
}
216
248
}
217
249
},
218
250
url: '/api/v{api-version}/collectionFormat',
···
223
255
export const types = <ThrowOnError extends boolean = false>(options: Options<TypesData, ThrowOnError>) => {
224
256
return (options.client ?? client).get<TypesResponses, unknown, ThrowOnError>({
225
257
querySerializer: {
226
-
array: {
227
-
explode: false,
228
-
style: 'form'
258
+
parameters: {
259
+
parameterArray: {
260
+
array: {
261
+
explode: false,
262
+
style: 'form'
263
+
}
264
+
},
265
+
parameterDictionary: {
266
+
object: {
267
+
explode: false,
268
+
style: 'form'
269
+
}
270
+
}
229
271
}
230
272
},
231
273
url: '/api/v{api-version}/types',
···
235
277
236
278
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
237
279
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
280
+
querySerializer: {
281
+
parameters: {
282
+
parameterObject: {
283
+
object: {
284
+
explode: false,
285
+
style: 'form'
286
+
}
287
+
},
288
+
parameterReference: {
289
+
object: {
290
+
explode: false,
291
+
style: 'form'
292
+
}
293
+
}
294
+
}
295
+
},
238
296
url: '/api/v{api-version}/complex',
239
297
...options
240
298
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/name-builder/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/name-builder/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/name-builder/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/name-builder/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/asClass/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/asClass/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/asClass/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/asClass/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/axios/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/axios/client/utils.gen.ts
···
14
14
allowReserved,
15
15
array,
16
16
object,
17
+
parameters = {},
17
18
}: QuerySerializerOptions = {}) => {
18
19
const querySerializer = (queryParams: T) => {
19
20
const search: string[] = [];
···
25
26
continue;
26
27
}
27
28
29
+
// Get parameter-specific settings or fall back to global
30
+
const paramConfig = parameters[name] || {};
31
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
32
+
28
33
if (Array.isArray(value)) {
29
34
const serializedArray = serializeArrayParam({
30
-
allowReserved,
35
+
allowReserved: paramAllowReserved,
31
36
explode: true,
32
37
name,
33
38
style: 'form',
34
39
value,
35
40
...array,
41
+
...paramConfig.array,
36
42
});
37
43
if (serializedArray) search.push(serializedArray);
38
44
} else if (typeof value === 'object') {
39
45
const serializedObject = serializeObjectParam({
40
-
allowReserved,
46
+
allowReserved: paramAllowReserved,
41
47
explode: true,
42
48
name,
43
49
style: 'deepObject',
44
50
value: value as Record<string, unknown>,
45
51
...object,
52
+
...paramConfig.object,
46
53
});
47
54
if (serializedObject) search.push(serializedObject);
48
55
} else {
49
56
const serializedPrimitive = serializePrimitiveParam({
50
-
allowReserved,
57
+
allowReserved: paramAllowReserved,
51
58
name,
52
59
value: value as string,
53
60
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/axios/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/axios/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/axios/sdk.gen.ts
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/axios/sdk.gen.ts
···
111
111
112
112
export const callWithDefaultParameters = <ThrowOnError extends boolean = false>(options: Options<CallWithDefaultParametersData, ThrowOnError>) => {
113
113
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
114
+
querySerializer: {
115
+
parameters: {
116
+
parameterModel: {
117
+
object: {
118
+
explode: false,
119
+
style: 'form'
120
+
}
121
+
}
122
+
}
123
+
},
114
124
url: '/api/v{api-version}/defaults',
115
125
...options
116
126
});
···
216
226
export const collectionFormat = <ThrowOnError extends boolean = false>(options: Options<CollectionFormatData, ThrowOnError>) => {
217
227
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
218
228
querySerializer: {
219
-
array: {
220
-
explode: false,
221
-
style: 'form'
229
+
parameters: {
230
+
parameterArrayCSV: {
231
+
array: {
232
+
explode: false,
233
+
style: 'form'
234
+
}
235
+
},
236
+
parameterArraySSV: {
237
+
array: {
238
+
explode: false,
239
+
style: 'form'
240
+
}
241
+
},
242
+
parameterArrayTSV: {
243
+
array: {
244
+
explode: false,
245
+
style: 'form'
246
+
}
247
+
},
248
+
parameterArrayPipes: {
249
+
array: {
250
+
explode: false,
251
+
style: 'form'
252
+
}
253
+
}
222
254
}
223
255
},
224
256
url: '/api/v{api-version}/collectionFormat',
···
229
261
export const types = <ThrowOnError extends boolean = false>(options: Options<TypesData, ThrowOnError>) => {
230
262
return (options.client ?? client).get<TypesResponses, unknown, ThrowOnError>({
231
263
querySerializer: {
232
-
array: {
233
-
explode: false,
234
-
style: 'form'
264
+
parameters: {
265
+
parameterArray: {
266
+
array: {
267
+
explode: false,
268
+
style: 'form'
269
+
}
270
+
},
271
+
parameterDictionary: {
272
+
object: {
273
+
explode: false,
274
+
style: 'form'
275
+
}
276
+
}
235
277
}
236
278
},
237
279
responseType: 'json',
···
242
284
243
285
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
244
286
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
287
+
querySerializer: {
288
+
parameters: {
289
+
parameterObject: {
290
+
object: {
291
+
explode: false,
292
+
style: 'form'
293
+
}
294
+
},
295
+
parameterReference: {
296
+
object: {
297
+
explode: false,
298
+
style: 'form'
299
+
}
300
+
}
301
+
}
302
+
},
245
303
responseType: 'json',
246
304
url: '/api/v{api-version}/complex',
247
305
...options
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/fetch/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/fetch/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/fetch/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/fetch/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/fetch/sdk.gen.ts
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/fetch/sdk.gen.ts
···
111
111
112
112
export const callWithDefaultParameters = <ThrowOnError extends boolean = false>(options: Options<CallWithDefaultParametersData, ThrowOnError>) => {
113
113
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
114
+
querySerializer: {
115
+
parameters: {
116
+
parameterModel: {
117
+
object: {
118
+
explode: false,
119
+
style: 'form'
120
+
}
121
+
}
122
+
}
123
+
},
114
124
url: '/api/v{api-version}/defaults',
115
125
...options
116
126
});
···
210
220
export const collectionFormat = <ThrowOnError extends boolean = false>(options: Options<CollectionFormatData, ThrowOnError>) => {
211
221
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
212
222
querySerializer: {
213
-
array: {
214
-
explode: false,
215
-
style: 'form'
223
+
parameters: {
224
+
parameterArrayCSV: {
225
+
array: {
226
+
explode: false,
227
+
style: 'form'
228
+
}
229
+
},
230
+
parameterArraySSV: {
231
+
array: {
232
+
explode: false,
233
+
style: 'form'
234
+
}
235
+
},
236
+
parameterArrayTSV: {
237
+
array: {
238
+
explode: false,
239
+
style: 'form'
240
+
}
241
+
},
242
+
parameterArrayPipes: {
243
+
array: {
244
+
explode: false,
245
+
style: 'form'
246
+
}
247
+
}
216
248
}
217
249
},
218
250
url: '/api/v{api-version}/collectionFormat',
···
223
255
export const types = <ThrowOnError extends boolean = false>(options: Options<TypesData, ThrowOnError>) => {
224
256
return (options.client ?? client).get<TypesResponses, unknown, ThrowOnError>({
225
257
querySerializer: {
226
-
array: {
227
-
explode: false,
228
-
style: 'form'
258
+
parameters: {
259
+
parameterArray: {
260
+
array: {
261
+
explode: false,
262
+
style: 'form'
263
+
}
264
+
},
265
+
parameterDictionary: {
266
+
object: {
267
+
explode: false,
268
+
style: 'form'
269
+
}
270
+
}
229
271
}
230
272
},
231
273
url: '/api/v{api-version}/types',
···
235
277
236
278
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
237
279
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
280
+
querySerializer: {
281
+
parameters: {
282
+
parameterObject: {
283
+
object: {
284
+
explode: false,
285
+
style: 'form'
286
+
}
287
+
},
288
+
parameterReference: {
289
+
object: {
290
+
explode: false,
291
+
style: 'form'
292
+
}
293
+
}
294
+
}
295
+
},
238
296
url: '/api/v{api-version}/complex',
239
297
...options
240
298
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/name-builder/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/name-builder/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/name-builder/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/name-builder/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/asClass/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/asClass/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/asClass/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/asClass/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/axios/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/axios/client/utils.gen.ts
···
14
14
allowReserved,
15
15
array,
16
16
object,
17
+
parameters = {},
17
18
}: QuerySerializerOptions = {}) => {
18
19
const querySerializer = (queryParams: T) => {
19
20
const search: string[] = [];
···
25
26
continue;
26
27
}
27
28
29
+
// Get parameter-specific settings or fall back to global
30
+
const paramConfig = parameters[name] || {};
31
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
32
+
28
33
if (Array.isArray(value)) {
29
34
const serializedArray = serializeArrayParam({
30
-
allowReserved,
35
+
allowReserved: paramAllowReserved,
31
36
explode: true,
32
37
name,
33
38
style: 'form',
34
39
value,
35
40
...array,
41
+
...paramConfig.array,
36
42
});
37
43
if (serializedArray) search.push(serializedArray);
38
44
} else if (typeof value === 'object') {
39
45
const serializedObject = serializeObjectParam({
40
-
allowReserved,
46
+
allowReserved: paramAllowReserved,
41
47
explode: true,
42
48
name,
43
49
style: 'deepObject',
44
50
value: value as Record<string, unknown>,
45
51
...object,
52
+
...paramConfig.object,
46
53
});
47
54
if (serializedObject) search.push(serializedObject);
48
55
} else {
49
56
const serializedPrimitive = serializePrimitiveParam({
50
-
allowReserved,
57
+
allowReserved: paramAllowReserved,
51
58
name,
52
59
value: value as string,
53
60
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/axios/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/axios/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/axios/sdk.gen.ts
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/axios/sdk.gen.ts
···
111
111
112
112
export const callWithDefaultParameters = <ThrowOnError extends boolean = false>(options: Options<CallWithDefaultParametersData, ThrowOnError>) => {
113
113
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
114
+
querySerializer: {
115
+
parameters: {
116
+
parameterModel: {
117
+
object: {
118
+
explode: false,
119
+
style: 'form'
120
+
}
121
+
}
122
+
}
123
+
},
114
124
url: '/api/v{api-version}/defaults',
115
125
...options
116
126
});
···
216
226
export const collectionFormat = <ThrowOnError extends boolean = false>(options: Options<CollectionFormatData, ThrowOnError>) => {
217
227
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
218
228
querySerializer: {
219
-
array: {
220
-
explode: false,
221
-
style: 'form'
229
+
parameters: {
230
+
parameterArrayCSV: {
231
+
array: {
232
+
explode: false,
233
+
style: 'form'
234
+
}
235
+
},
236
+
parameterArraySSV: {
237
+
array: {
238
+
explode: false,
239
+
style: 'form'
240
+
}
241
+
},
242
+
parameterArrayTSV: {
243
+
array: {
244
+
explode: false,
245
+
style: 'form'
246
+
}
247
+
},
248
+
parameterArrayPipes: {
249
+
array: {
250
+
explode: false,
251
+
style: 'form'
252
+
}
253
+
}
222
254
}
223
255
},
224
256
url: '/api/v{api-version}/collectionFormat',
···
229
261
export const types = <ThrowOnError extends boolean = false>(options: Options<TypesData, ThrowOnError>) => {
230
262
return (options.client ?? client).get<TypesResponses, unknown, ThrowOnError>({
231
263
querySerializer: {
232
-
array: {
233
-
explode: false,
234
-
style: 'form'
264
+
parameters: {
265
+
parameterArray: {
266
+
array: {
267
+
explode: false,
268
+
style: 'form'
269
+
}
270
+
},
271
+
parameterDictionary: {
272
+
object: {
273
+
explode: false,
274
+
style: 'form'
275
+
}
276
+
}
235
277
}
236
278
},
237
279
responseType: 'json',
···
242
284
243
285
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
244
286
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
287
+
querySerializer: {
288
+
parameters: {
289
+
parameterObject: {
290
+
object: {
291
+
explode: false,
292
+
style: 'form'
293
+
}
294
+
},
295
+
parameterReference: {
296
+
object: {
297
+
explode: false,
298
+
style: 'form'
299
+
}
300
+
}
301
+
}
302
+
},
245
303
responseType: 'json',
246
304
url: '/api/v{api-version}/complex',
247
305
...options
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/fetch/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/fetch/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/fetch/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/fetch/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/fetch/sdk.gen.ts
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/fetch/sdk.gen.ts
···
111
111
112
112
export const callWithDefaultParameters = <ThrowOnError extends boolean = false>(options: Options<CallWithDefaultParametersData, ThrowOnError>) => {
113
113
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
114
+
querySerializer: {
115
+
parameters: {
116
+
parameterModel: {
117
+
object: {
118
+
explode: false,
119
+
style: 'form'
120
+
}
121
+
}
122
+
}
123
+
},
114
124
url: '/api/v{api-version}/defaults',
115
125
...options
116
126
});
···
210
220
export const collectionFormat = <ThrowOnError extends boolean = false>(options: Options<CollectionFormatData, ThrowOnError>) => {
211
221
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
212
222
querySerializer: {
213
-
array: {
214
-
explode: false,
215
-
style: 'form'
223
+
parameters: {
224
+
parameterArrayCSV: {
225
+
array: {
226
+
explode: false,
227
+
style: 'form'
228
+
}
229
+
},
230
+
parameterArraySSV: {
231
+
array: {
232
+
explode: false,
233
+
style: 'form'
234
+
}
235
+
},
236
+
parameterArrayTSV: {
237
+
array: {
238
+
explode: false,
239
+
style: 'form'
240
+
}
241
+
},
242
+
parameterArrayPipes: {
243
+
array: {
244
+
explode: false,
245
+
style: 'form'
246
+
}
247
+
}
216
248
}
217
249
},
218
250
url: '/api/v{api-version}/collectionFormat',
···
223
255
export const types = <ThrowOnError extends boolean = false>(options: Options<TypesData, ThrowOnError>) => {
224
256
return (options.client ?? client).get<TypesResponses, unknown, ThrowOnError>({
225
257
querySerializer: {
226
-
array: {
227
-
explode: false,
228
-
style: 'form'
258
+
parameters: {
259
+
parameterArray: {
260
+
array: {
261
+
explode: false,
262
+
style: 'form'
263
+
}
264
+
},
265
+
parameterDictionary: {
266
+
object: {
267
+
explode: false,
268
+
style: 'form'
269
+
}
270
+
}
229
271
}
230
272
},
231
273
url: '/api/v{api-version}/types',
···
235
277
236
278
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
237
279
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
280
+
querySerializer: {
281
+
parameters: {
282
+
parameterObject: {
283
+
object: {
284
+
explode: false,
285
+
style: 'form'
286
+
}
287
+
},
288
+
parameterReference: {
289
+
object: {
290
+
explode: false,
291
+
style: 'form'
292
+
}
293
+
}
294
+
}
295
+
},
238
296
url: '/api/v{api-version}/complex',
239
297
...options
240
298
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/name-builder/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/name-builder/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/name-builder/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/name-builder/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/asClass/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/asClass/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/asClass/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/asClass/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/axios/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/axios/client/utils.gen.ts
···
14
14
allowReserved,
15
15
array,
16
16
object,
17
+
parameters = {},
17
18
}: QuerySerializerOptions = {}) => {
18
19
const querySerializer = (queryParams: T) => {
19
20
const search: string[] = [];
···
25
26
continue;
26
27
}
27
28
29
+
// Get parameter-specific settings or fall back to global
30
+
const paramConfig = parameters[name] || {};
31
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
32
+
28
33
if (Array.isArray(value)) {
29
34
const serializedArray = serializeArrayParam({
30
-
allowReserved,
35
+
allowReserved: paramAllowReserved,
31
36
explode: true,
32
37
name,
33
38
style: 'form',
34
39
value,
35
40
...array,
41
+
...paramConfig.array,
36
42
});
37
43
if (serializedArray) search.push(serializedArray);
38
44
} else if (typeof value === 'object') {
39
45
const serializedObject = serializeObjectParam({
40
-
allowReserved,
46
+
allowReserved: paramAllowReserved,
41
47
explode: true,
42
48
name,
43
49
style: 'deepObject',
44
50
value: value as Record<string, unknown>,
45
51
...object,
52
+
...paramConfig.object,
46
53
});
47
54
if (serializedObject) search.push(serializedObject);
48
55
} else {
49
56
const serializedPrimitive = serializePrimitiveParam({
50
-
allowReserved,
57
+
allowReserved: paramAllowReserved,
51
58
name,
52
59
value: value as string,
53
60
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/axios/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/axios/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/axios/sdk.gen.ts
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/axios/sdk.gen.ts
···
111
111
112
112
export const callWithDefaultParameters = <ThrowOnError extends boolean = false>(options: Options<CallWithDefaultParametersData, ThrowOnError>) => {
113
113
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
114
+
querySerializer: {
115
+
parameters: {
116
+
parameterModel: {
117
+
object: {
118
+
explode: false,
119
+
style: 'form'
120
+
}
121
+
}
122
+
}
123
+
},
114
124
url: '/api/v{api-version}/defaults',
115
125
...options
116
126
});
···
216
226
export const collectionFormat = <ThrowOnError extends boolean = false>(options: Options<CollectionFormatData, ThrowOnError>) => {
217
227
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
218
228
querySerializer: {
219
-
array: {
220
-
explode: false,
221
-
style: 'form'
229
+
parameters: {
230
+
parameterArrayCSV: {
231
+
array: {
232
+
explode: false,
233
+
style: 'form'
234
+
}
235
+
},
236
+
parameterArraySSV: {
237
+
array: {
238
+
explode: false,
239
+
style: 'form'
240
+
}
241
+
},
242
+
parameterArrayTSV: {
243
+
array: {
244
+
explode: false,
245
+
style: 'form'
246
+
}
247
+
},
248
+
parameterArrayPipes: {
249
+
array: {
250
+
explode: false,
251
+
style: 'form'
252
+
}
253
+
}
222
254
}
223
255
},
224
256
url: '/api/v{api-version}/collectionFormat',
···
229
261
export const types = <ThrowOnError extends boolean = false>(options: Options<TypesData, ThrowOnError>) => {
230
262
return (options.client ?? client).get<TypesResponses, unknown, ThrowOnError>({
231
263
querySerializer: {
232
-
array: {
233
-
explode: false,
234
-
style: 'form'
264
+
parameters: {
265
+
parameterArray: {
266
+
array: {
267
+
explode: false,
268
+
style: 'form'
269
+
}
270
+
},
271
+
parameterDictionary: {
272
+
object: {
273
+
explode: false,
274
+
style: 'form'
275
+
}
276
+
}
235
277
}
236
278
},
237
279
responseType: 'json',
···
242
284
243
285
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
244
286
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
287
+
querySerializer: {
288
+
parameters: {
289
+
parameterObject: {
290
+
object: {
291
+
explode: false,
292
+
style: 'form'
293
+
}
294
+
},
295
+
parameterReference: {
296
+
object: {
297
+
explode: false,
298
+
style: 'form'
299
+
}
300
+
}
301
+
}
302
+
},
245
303
responseType: 'json',
246
304
url: '/api/v{api-version}/complex',
247
305
...options
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/fetch/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/fetch/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/fetch/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/fetch/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/fetch/sdk.gen.ts
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/fetch/sdk.gen.ts
···
111
111
112
112
export const callWithDefaultParameters = <ThrowOnError extends boolean = false>(options: Options<CallWithDefaultParametersData, ThrowOnError>) => {
113
113
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
114
+
querySerializer: {
115
+
parameters: {
116
+
parameterModel: {
117
+
object: {
118
+
explode: false,
119
+
style: 'form'
120
+
}
121
+
}
122
+
}
123
+
},
114
124
url: '/api/v{api-version}/defaults',
115
125
...options
116
126
});
···
210
220
export const collectionFormat = <ThrowOnError extends boolean = false>(options: Options<CollectionFormatData, ThrowOnError>) => {
211
221
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
212
222
querySerializer: {
213
-
array: {
214
-
explode: false,
215
-
style: 'form'
223
+
parameters: {
224
+
parameterArrayCSV: {
225
+
array: {
226
+
explode: false,
227
+
style: 'form'
228
+
}
229
+
},
230
+
parameterArraySSV: {
231
+
array: {
232
+
explode: false,
233
+
style: 'form'
234
+
}
235
+
},
236
+
parameterArrayTSV: {
237
+
array: {
238
+
explode: false,
239
+
style: 'form'
240
+
}
241
+
},
242
+
parameterArrayPipes: {
243
+
array: {
244
+
explode: false,
245
+
style: 'form'
246
+
}
247
+
}
216
248
}
217
249
},
218
250
url: '/api/v{api-version}/collectionFormat',
···
223
255
export const types = <ThrowOnError extends boolean = false>(options: Options<TypesData, ThrowOnError>) => {
224
256
return (options.client ?? client).get<TypesResponses, unknown, ThrowOnError>({
225
257
querySerializer: {
226
-
array: {
227
-
explode: false,
228
-
style: 'form'
258
+
parameters: {
259
+
parameterArray: {
260
+
array: {
261
+
explode: false,
262
+
style: 'form'
263
+
}
264
+
},
265
+
parameterDictionary: {
266
+
object: {
267
+
explode: false,
268
+
style: 'form'
269
+
}
270
+
}
229
271
}
230
272
},
231
273
url: '/api/v{api-version}/types',
···
235
277
236
278
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
237
279
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
280
+
querySerializer: {
281
+
parameters: {
282
+
parameterObject: {
283
+
object: {
284
+
explode: false,
285
+
style: 'form'
286
+
}
287
+
},
288
+
parameterReference: {
289
+
object: {
290
+
explode: false,
291
+
style: 'form'
292
+
}
293
+
}
294
+
}
295
+
},
238
296
url: '/api/v{api-version}/complex',
239
297
...options
240
298
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/name-builder/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/name-builder/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/name-builder/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/name-builder/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/asClass/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/asClass/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/asClass/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/asClass/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/axios/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/axios/client/utils.gen.ts
···
14
14
allowReserved,
15
15
array,
16
16
object,
17
+
parameters = {},
17
18
}: QuerySerializerOptions = {}) => {
18
19
const querySerializer = (queryParams: T) => {
19
20
const search: string[] = [];
···
25
26
continue;
26
27
}
27
28
29
+
// Get parameter-specific settings or fall back to global
30
+
const paramConfig = parameters[name] || {};
31
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
32
+
28
33
if (Array.isArray(value)) {
29
34
const serializedArray = serializeArrayParam({
30
-
allowReserved,
35
+
allowReserved: paramAllowReserved,
31
36
explode: true,
32
37
name,
33
38
style: 'form',
34
39
value,
35
40
...array,
41
+
...paramConfig.array,
36
42
});
37
43
if (serializedArray) search.push(serializedArray);
38
44
} else if (typeof value === 'object') {
39
45
const serializedObject = serializeObjectParam({
40
-
allowReserved,
46
+
allowReserved: paramAllowReserved,
41
47
explode: true,
42
48
name,
43
49
style: 'deepObject',
44
50
value: value as Record<string, unknown>,
45
51
...object,
52
+
...paramConfig.object,
46
53
});
47
54
if (serializedObject) search.push(serializedObject);
48
55
} else {
49
56
const serializedPrimitive = serializePrimitiveParam({
50
-
allowReserved,
57
+
allowReserved: paramAllowReserved,
51
58
name,
52
59
value: value as string,
53
60
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/axios/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/axios/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/axios/sdk.gen.ts
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/axios/sdk.gen.ts
···
111
111
112
112
export const callWithDefaultParameters = <ThrowOnError extends boolean = false>(options: Options<CallWithDefaultParametersData, ThrowOnError>) => {
113
113
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
114
+
querySerializer: {
115
+
parameters: {
116
+
parameterModel: {
117
+
object: {
118
+
explode: false,
119
+
style: 'form'
120
+
}
121
+
}
122
+
}
123
+
},
114
124
url: '/api/v{api-version}/defaults',
115
125
...options
116
126
});
···
216
226
export const collectionFormat = <ThrowOnError extends boolean = false>(options: Options<CollectionFormatData, ThrowOnError>) => {
217
227
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
218
228
querySerializer: {
219
-
array: {
220
-
explode: false,
221
-
style: 'form'
229
+
parameters: {
230
+
parameterArrayCSV: {
231
+
array: {
232
+
explode: false,
233
+
style: 'form'
234
+
}
235
+
},
236
+
parameterArraySSV: {
237
+
array: {
238
+
explode: false,
239
+
style: 'form'
240
+
}
241
+
},
242
+
parameterArrayTSV: {
243
+
array: {
244
+
explode: false,
245
+
style: 'form'
246
+
}
247
+
},
248
+
parameterArrayPipes: {
249
+
array: {
250
+
explode: false,
251
+
style: 'form'
252
+
}
253
+
}
222
254
}
223
255
},
224
256
url: '/api/v{api-version}/collectionFormat',
···
229
261
export const types = <ThrowOnError extends boolean = false>(options: Options<TypesData, ThrowOnError>) => {
230
262
return (options.client ?? client).get<TypesResponses, unknown, ThrowOnError>({
231
263
querySerializer: {
232
-
array: {
233
-
explode: false,
234
-
style: 'form'
264
+
parameters: {
265
+
parameterArray: {
266
+
array: {
267
+
explode: false,
268
+
style: 'form'
269
+
}
270
+
},
271
+
parameterDictionary: {
272
+
object: {
273
+
explode: false,
274
+
style: 'form'
275
+
}
276
+
}
235
277
}
236
278
},
237
279
responseType: 'json',
···
242
284
243
285
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
244
286
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
287
+
querySerializer: {
288
+
parameters: {
289
+
parameterObject: {
290
+
object: {
291
+
explode: false,
292
+
style: 'form'
293
+
}
294
+
},
295
+
parameterReference: {
296
+
object: {
297
+
explode: false,
298
+
style: 'form'
299
+
}
300
+
}
301
+
}
302
+
},
245
303
responseType: 'json',
246
304
url: '/api/v{api-version}/complex',
247
305
...options
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/fetch/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/fetch/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/fetch/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/fetch/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/fetch/sdk.gen.ts
+64
-6
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/fetch/sdk.gen.ts
···
111
111
112
112
export const callWithDefaultParameters = <ThrowOnError extends boolean = false>(options: Options<CallWithDefaultParametersData, ThrowOnError>) => {
113
113
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
114
+
querySerializer: {
115
+
parameters: {
116
+
parameterModel: {
117
+
object: {
118
+
explode: false,
119
+
style: 'form'
120
+
}
121
+
}
122
+
}
123
+
},
114
124
url: '/api/v{api-version}/defaults',
115
125
...options
116
126
});
···
210
220
export const collectionFormat = <ThrowOnError extends boolean = false>(options: Options<CollectionFormatData, ThrowOnError>) => {
211
221
return (options.client ?? client).get<unknown, unknown, ThrowOnError>({
212
222
querySerializer: {
213
-
array: {
214
-
explode: false,
215
-
style: 'form'
223
+
parameters: {
224
+
parameterArrayCSV: {
225
+
array: {
226
+
explode: false,
227
+
style: 'form'
228
+
}
229
+
},
230
+
parameterArraySSV: {
231
+
array: {
232
+
explode: false,
233
+
style: 'form'
234
+
}
235
+
},
236
+
parameterArrayTSV: {
237
+
array: {
238
+
explode: false,
239
+
style: 'form'
240
+
}
241
+
},
242
+
parameterArrayPipes: {
243
+
array: {
244
+
explode: false,
245
+
style: 'form'
246
+
}
247
+
}
216
248
}
217
249
},
218
250
url: '/api/v{api-version}/collectionFormat',
···
223
255
export const types = <ThrowOnError extends boolean = false>(options: Options<TypesData, ThrowOnError>) => {
224
256
return (options.client ?? client).get<TypesResponses, unknown, ThrowOnError>({
225
257
querySerializer: {
226
-
array: {
227
-
explode: false,
228
-
style: 'form'
258
+
parameters: {
259
+
parameterArray: {
260
+
array: {
261
+
explode: false,
262
+
style: 'form'
263
+
}
264
+
},
265
+
parameterDictionary: {
266
+
object: {
267
+
explode: false,
268
+
style: 'form'
269
+
}
270
+
}
229
271
}
230
272
},
231
273
url: '/api/v{api-version}/types',
···
235
277
236
278
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
237
279
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
280
+
querySerializer: {
281
+
parameters: {
282
+
parameterObject: {
283
+
object: {
284
+
explode: false,
285
+
style: 'form'
286
+
}
287
+
},
288
+
parameterReference: {
289
+
object: {
290
+
explode: false,
291
+
style: 'form'
292
+
}
293
+
}
294
+
}
295
+
},
238
296
url: '/api/v{api-version}/complex',
239
297
...options
240
298
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/name-builder/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/name-builder/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/name-builder/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/name-builder/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/schema-unknown/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/schema-unknown/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/schema-unknown/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/schema-unknown/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/security-api-key/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/security-api-key/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/security-api-key/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/security-api-key/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/security-basic/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/security-basic/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/security-basic/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/security-basic/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/security-false/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/security-false/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/security-false/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/security-false/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/security-oauth2/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/security-oauth2/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/security-oauth2/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/security-oauth2/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/servers-base-path/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/servers-base-path/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/servers-base-path/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/servers-base-path/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/servers-host/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/servers-host/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/servers-host/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/servers-host/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/servers/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/servers/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/servers/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/servers/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/transforms-read-write/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/transforms-read-write/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/transforms-read-write/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/transforms-read-write/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/body-response-text-plain/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/body-response-text-plain/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/body-response-text-plain/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/body-response-text-plain/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/content-types/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/content-types/client/utils.gen.ts
···
14
14
allowReserved,
15
15
array,
16
16
object,
17
+
parameters = {},
17
18
}: QuerySerializerOptions = {}) => {
18
19
const querySerializer = (queryParams: T) => {
19
20
const search: string[] = [];
···
25
26
continue;
26
27
}
27
28
29
+
// Get parameter-specific settings or fall back to global
30
+
const paramConfig = parameters[name] || {};
31
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
32
+
28
33
if (Array.isArray(value)) {
29
34
const serializedArray = serializeArrayParam({
30
-
allowReserved,
35
+
allowReserved: paramAllowReserved,
31
36
explode: true,
32
37
name,
33
38
style: 'form',
34
39
value,
35
40
...array,
41
+
...paramConfig.array,
36
42
});
37
43
if (serializedArray) search.push(serializedArray);
38
44
} else if (typeof value === 'object') {
39
45
const serializedObject = serializeObjectParam({
40
-
allowReserved,
46
+
allowReserved: paramAllowReserved,
41
47
explode: true,
42
48
name,
43
49
style: 'deepObject',
44
50
value: value as Record<string, unknown>,
45
51
...object,
52
+
...paramConfig.object,
46
53
});
47
54
if (serializedObject) search.push(serializedObject);
48
55
} else {
49
56
const serializedPrimitive = serializePrimitiveParam({
50
-
allowReserved,
57
+
allowReserved: paramAllowReserved,
51
58
name,
52
59
value: value as string,
53
60
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/content-types/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/content-types/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/internal-name-conflict/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/internal-name-conflict/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/internal-name-conflict/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/internal-name-conflict/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/parameter-explode-false-axios/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/parameter-explode-false-axios/client/utils.gen.ts
···
14
14
allowReserved,
15
15
array,
16
16
object,
17
+
parameters = {},
17
18
}: QuerySerializerOptions = {}) => {
18
19
const querySerializer = (queryParams: T) => {
19
20
const search: string[] = [];
···
25
26
continue;
26
27
}
27
28
29
+
// Get parameter-specific settings or fall back to global
30
+
const paramConfig = parameters[name] || {};
31
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
32
+
28
33
if (Array.isArray(value)) {
29
34
const serializedArray = serializeArrayParam({
30
-
allowReserved,
35
+
allowReserved: paramAllowReserved,
31
36
explode: true,
32
37
name,
33
38
style: 'form',
34
39
value,
35
40
...array,
41
+
...paramConfig.array,
36
42
});
37
43
if (serializedArray) search.push(serializedArray);
38
44
} else if (typeof value === 'object') {
39
45
const serializedObject = serializeObjectParam({
40
-
allowReserved,
46
+
allowReserved: paramAllowReserved,
41
47
explode: true,
42
48
name,
43
49
style: 'deepObject',
44
50
value: value as Record<string, unknown>,
45
51
...object,
52
+
...paramConfig.object,
46
53
});
47
54
if (serializedObject) search.push(serializedObject);
48
55
} else {
49
56
const serializedPrimitive = serializePrimitiveParam({
50
-
allowReserved,
57
+
allowReserved: paramAllowReserved,
51
58
name,
52
59
value: value as string,
53
60
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/parameter-explode-false-axios/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/parameter-explode-false-axios/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+7
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/parameter-explode-false-axios/sdk.gen.ts
+7
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/parameter-explode-false-axios/sdk.gen.ts
···
21
21
export const postFoo = <ThrowOnError extends boolean = false>(options?: Options<PostFooData, ThrowOnError>) => {
22
22
return (options?.client ?? client).post<PostFooResponses, unknown, ThrowOnError>({
23
23
querySerializer: {
24
-
array: {
25
-
explode: false,
26
-
style: 'form'
24
+
parameters: {
25
+
foo: {
26
+
array: {
27
+
explode: false,
28
+
style: 'form'
29
+
}
30
+
}
27
31
}
28
32
},
29
33
url: '/foo',
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/parameter-explode-false/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/parameter-explode-false/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/parameter-explode-false/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/parameter-explode-false/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+7
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/parameter-explode-false/sdk.gen.ts
+7
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/parameter-explode-false/sdk.gen.ts
···
21
21
export const postFoo = <ThrowOnError extends boolean = false>(options?: Options<PostFooData, ThrowOnError>) => {
22
22
return (options?.client ?? client).post<PostFooResponses, unknown, ThrowOnError>({
23
23
querySerializer: {
24
-
array: {
25
-
explode: false,
26
-
style: 'form'
24
+
parameters: {
25
+
foo: {
26
+
array: {
27
+
explode: false,
28
+
style: 'form'
29
+
}
30
+
}
27
31
}
28
32
},
29
33
url: '/foo',
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@angular/common/default-class/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@angular/common/default-class/client/utils.gen.ts
···
99
99
allowReserved,
100
100
array,
101
101
object,
102
+
parameters = {},
102
103
}: QuerySerializerOptions = {}) => {
103
104
const querySerializer = (queryParams: T) => {
104
105
const search: string[] = [];
···
110
111
continue;
111
112
}
112
113
114
+
// Get parameter-specific settings or fall back to global
115
+
const paramConfig = parameters[name] || {};
116
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
117
+
113
118
if (Array.isArray(value)) {
114
119
const serializedArray = serializeArrayParam({
115
-
allowReserved,
120
+
allowReserved: paramAllowReserved,
116
121
explode: true,
117
122
name,
118
123
style: 'form',
119
124
value,
120
125
...array,
126
+
...paramConfig.array,
121
127
});
122
128
if (serializedArray) search.push(serializedArray);
123
129
} else if (typeof value === 'object') {
124
130
const serializedObject = serializeObjectParam({
125
-
allowReserved,
131
+
allowReserved: paramAllowReserved,
126
132
explode: true,
127
133
name,
128
134
style: 'deepObject',
129
135
value: value as Record<string, unknown>,
130
136
...object,
137
+
...paramConfig.object,
131
138
});
132
139
if (serializedObject) search.push(serializedObject);
133
140
} else {
134
141
const serializedPrimitive = serializePrimitiveParam({
135
-
allowReserved,
142
+
allowReserved: paramAllowReserved,
136
143
name,
137
144
value: value as string,
138
145
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@angular/common/default-class/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@angular/common/default-class/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@angular/common/default-class/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@angular/common/default-class/sdk.gen.ts
···
337
337
338
338
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
339
339
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
340
+
querySerializer: {
341
+
parameters: {
342
+
parameterObject: {
343
+
object: {
344
+
explode: true,
345
+
style: 'form'
346
+
}
347
+
}
348
+
}
349
+
},
340
350
url: '/api/v{api-version}/complex',
341
351
...options
342
352
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@angular/common/default/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@angular/common/default/client/utils.gen.ts
···
99
99
allowReserved,
100
100
array,
101
101
object,
102
+
parameters = {},
102
103
}: QuerySerializerOptions = {}) => {
103
104
const querySerializer = (queryParams: T) => {
104
105
const search: string[] = [];
···
110
111
continue;
111
112
}
112
113
114
+
// Get parameter-specific settings or fall back to global
115
+
const paramConfig = parameters[name] || {};
116
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
117
+
113
118
if (Array.isArray(value)) {
114
119
const serializedArray = serializeArrayParam({
115
-
allowReserved,
120
+
allowReserved: paramAllowReserved,
116
121
explode: true,
117
122
name,
118
123
style: 'form',
119
124
value,
120
125
...array,
126
+
...paramConfig.array,
121
127
});
122
128
if (serializedArray) search.push(serializedArray);
123
129
} else if (typeof value === 'object') {
124
130
const serializedObject = serializeObjectParam({
125
-
allowReserved,
131
+
allowReserved: paramAllowReserved,
126
132
explode: true,
127
133
name,
128
134
style: 'deepObject',
129
135
value: value as Record<string, unknown>,
130
136
...object,
137
+
...paramConfig.object,
131
138
});
132
139
if (serializedObject) search.push(serializedObject);
133
140
} else {
134
141
const serializedPrimitive = serializePrimitiveParam({
135
-
allowReserved,
142
+
allowReserved: paramAllowReserved,
136
143
name,
137
144
value: value as string,
138
145
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@angular/common/default/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@angular/common/default/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@angular/common/default/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@angular/common/default/sdk.gen.ts
···
337
337
338
338
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
339
339
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
340
+
querySerializer: {
341
+
parameters: {
342
+
parameterObject: {
343
+
object: {
344
+
explode: true,
345
+
style: 'form'
346
+
}
347
+
}
348
+
}
349
+
},
340
350
url: '/api/v{api-version}/complex',
341
351
...options
342
352
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/client-fetch/sdk-nested-classes-instance/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/client-fetch/sdk-nested-classes-instance/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/client-fetch/sdk-nested-classes-instance/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/client-fetch/sdk-nested-classes-instance/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/client-fetch/sdk-nested-classes/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/client-fetch/sdk-nested-classes/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/client-fetch/sdk-nested-classes/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/client-fetch/sdk-nested-classes/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/sdk/default/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/sdk/default/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/sdk/default/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/sdk/default/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/sdk/default/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/sdk/default/sdk.gen.ts
···
337
337
338
338
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
339
339
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
340
+
querySerializer: {
341
+
parameters: {
342
+
parameterObject: {
343
+
object: {
344
+
explode: true,
345
+
style: 'form'
346
+
}
347
+
}
348
+
}
349
+
},
340
350
url: '/api/v{api-version}/complex',
341
351
...options
342
352
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/sdk/instance/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/sdk/instance/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/sdk/instance/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/sdk/instance/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/sdk/throwOnError/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/sdk/throwOnError/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/sdk/throwOnError/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/sdk/throwOnError/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/sdk/throwOnError/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/sdk/throwOnError/sdk.gen.ts
···
337
337
338
338
export const complexTypes = <ThrowOnError extends boolean = true>(options: Options<ComplexTypesData, ThrowOnError>) => {
339
339
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
340
+
querySerializer: {
341
+
parameters: {
342
+
parameterObject: {
343
+
object: {
344
+
explode: true,
345
+
style: 'form'
346
+
}
347
+
}
348
+
}
349
+
},
340
350
url: '/api/v{api-version}/complex',
341
351
...options
342
352
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/transformers/type-format-valibot/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/transformers/type-format-valibot/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/transformers/type-format-valibot/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/transformers/type-format-valibot/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/transformers/type-format-zod/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/transformers/type-format-zod/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/transformers/type-format-zod/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/transformers/type-format-zod/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/typescript/transforms-read-write-custom-name/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/typescript/transforms-read-write-custom-name/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/typescript/transforms-read-write-custom-name/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/typescript/transforms-read-write-custom-name/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/typescript/transforms-read-write-ignore/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/typescript/transforms-read-write-ignore/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/typescript/transforms-read-write-ignore/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/typescript/transforms-read-write-ignore/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@pinia/colada/asClass/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@pinia/colada/asClass/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@pinia/colada/asClass/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@pinia/colada/asClass/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@pinia/colada/fetch/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@pinia/colada/fetch/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@pinia/colada/fetch/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@pinia/colada/fetch/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@pinia/colada/fetch/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@pinia/colada/fetch/sdk.gen.ts
···
337
337
338
338
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
339
339
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
340
+
querySerializer: {
341
+
parameters: {
342
+
parameterObject: {
343
+
object: {
344
+
explode: true,
345
+
style: 'form'
346
+
}
347
+
}
348
+
}
349
+
},
340
350
url: '/api/v{api-version}/complex',
341
351
...options
342
352
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/asClass/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/asClass/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/asClass/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/asClass/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/axios/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/axios/client/utils.gen.ts
···
14
14
allowReserved,
15
15
array,
16
16
object,
17
+
parameters = {},
17
18
}: QuerySerializerOptions = {}) => {
18
19
const querySerializer = (queryParams: T) => {
19
20
const search: string[] = [];
···
25
26
continue;
26
27
}
27
28
29
+
// Get parameter-specific settings or fall back to global
30
+
const paramConfig = parameters[name] || {};
31
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
32
+
28
33
if (Array.isArray(value)) {
29
34
const serializedArray = serializeArrayParam({
30
-
allowReserved,
35
+
allowReserved: paramAllowReserved,
31
36
explode: true,
32
37
name,
33
38
style: 'form',
34
39
value,
35
40
...array,
41
+
...paramConfig.array,
36
42
});
37
43
if (serializedArray) search.push(serializedArray);
38
44
} else if (typeof value === 'object') {
39
45
const serializedObject = serializeObjectParam({
40
-
allowReserved,
46
+
allowReserved: paramAllowReserved,
41
47
explode: true,
42
48
name,
43
49
style: 'deepObject',
44
50
value: value as Record<string, unknown>,
45
51
...object,
52
+
...paramConfig.object,
46
53
});
47
54
if (serializedObject) search.push(serializedObject);
48
55
} else {
49
56
const serializedPrimitive = serializePrimitiveParam({
50
-
allowReserved,
57
+
allowReserved: paramAllowReserved,
51
58
name,
52
59
value: value as string,
53
60
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/axios/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/axios/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/axios/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/axios/sdk.gen.ts
···
348
348
349
349
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
350
350
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
351
+
querySerializer: {
352
+
parameters: {
353
+
parameterObject: {
354
+
object: {
355
+
explode: true,
356
+
style: 'form'
357
+
}
358
+
}
359
+
}
360
+
},
351
361
responseType: 'json',
352
362
url: '/api/v{api-version}/complex',
353
363
...options
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/fetch/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/fetch/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/fetch/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/fetch/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/fetch/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/fetch/sdk.gen.ts
···
337
337
338
338
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
339
339
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
340
+
querySerializer: {
341
+
parameters: {
342
+
parameterObject: {
343
+
object: {
344
+
explode: true,
345
+
style: 'form'
346
+
}
347
+
}
348
+
}
349
+
},
340
350
url: '/api/v{api-version}/complex',
341
351
...options
342
352
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/name-builder/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/name-builder/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/name-builder/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/name-builder/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/asClass/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/asClass/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/asClass/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/asClass/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/axios/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/axios/client/utils.gen.ts
···
14
14
allowReserved,
15
15
array,
16
16
object,
17
+
parameters = {},
17
18
}: QuerySerializerOptions = {}) => {
18
19
const querySerializer = (queryParams: T) => {
19
20
const search: string[] = [];
···
25
26
continue;
26
27
}
27
28
29
+
// Get parameter-specific settings or fall back to global
30
+
const paramConfig = parameters[name] || {};
31
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
32
+
28
33
if (Array.isArray(value)) {
29
34
const serializedArray = serializeArrayParam({
30
-
allowReserved,
35
+
allowReserved: paramAllowReserved,
31
36
explode: true,
32
37
name,
33
38
style: 'form',
34
39
value,
35
40
...array,
41
+
...paramConfig.array,
36
42
});
37
43
if (serializedArray) search.push(serializedArray);
38
44
} else if (typeof value === 'object') {
39
45
const serializedObject = serializeObjectParam({
40
-
allowReserved,
46
+
allowReserved: paramAllowReserved,
41
47
explode: true,
42
48
name,
43
49
style: 'deepObject',
44
50
value: value as Record<string, unknown>,
45
51
...object,
52
+
...paramConfig.object,
46
53
});
47
54
if (serializedObject) search.push(serializedObject);
48
55
} else {
49
56
const serializedPrimitive = serializePrimitiveParam({
50
-
allowReserved,
57
+
allowReserved: paramAllowReserved,
51
58
name,
52
59
value: value as string,
53
60
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/axios/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/axios/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/axios/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/axios/sdk.gen.ts
···
348
348
349
349
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
350
350
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
351
+
querySerializer: {
352
+
parameters: {
353
+
parameterObject: {
354
+
object: {
355
+
explode: true,
356
+
style: 'form'
357
+
}
358
+
}
359
+
}
360
+
},
351
361
responseType: 'json',
352
362
url: '/api/v{api-version}/complex',
353
363
...options
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/fetch/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/fetch/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/fetch/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/fetch/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/fetch/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/fetch/sdk.gen.ts
···
337
337
338
338
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
339
339
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
340
+
querySerializer: {
341
+
parameters: {
342
+
parameterObject: {
343
+
object: {
344
+
explode: true,
345
+
style: 'form'
346
+
}
347
+
}
348
+
}
349
+
},
340
350
url: '/api/v{api-version}/complex',
341
351
...options
342
352
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/name-builder/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/name-builder/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/name-builder/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/name-builder/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/asClass/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/asClass/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/asClass/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/asClass/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/axios/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/axios/client/utils.gen.ts
···
14
14
allowReserved,
15
15
array,
16
16
object,
17
+
parameters = {},
17
18
}: QuerySerializerOptions = {}) => {
18
19
const querySerializer = (queryParams: T) => {
19
20
const search: string[] = [];
···
25
26
continue;
26
27
}
27
28
29
+
// Get parameter-specific settings or fall back to global
30
+
const paramConfig = parameters[name] || {};
31
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
32
+
28
33
if (Array.isArray(value)) {
29
34
const serializedArray = serializeArrayParam({
30
-
allowReserved,
35
+
allowReserved: paramAllowReserved,
31
36
explode: true,
32
37
name,
33
38
style: 'form',
34
39
value,
35
40
...array,
41
+
...paramConfig.array,
36
42
});
37
43
if (serializedArray) search.push(serializedArray);
38
44
} else if (typeof value === 'object') {
39
45
const serializedObject = serializeObjectParam({
40
-
allowReserved,
46
+
allowReserved: paramAllowReserved,
41
47
explode: true,
42
48
name,
43
49
style: 'deepObject',
44
50
value: value as Record<string, unknown>,
45
51
...object,
52
+
...paramConfig.object,
46
53
});
47
54
if (serializedObject) search.push(serializedObject);
48
55
} else {
49
56
const serializedPrimitive = serializePrimitiveParam({
50
-
allowReserved,
57
+
allowReserved: paramAllowReserved,
51
58
name,
52
59
value: value as string,
53
60
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/axios/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/axios/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/axios/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/axios/sdk.gen.ts
···
348
348
349
349
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
350
350
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
351
+
querySerializer: {
352
+
parameters: {
353
+
parameterObject: {
354
+
object: {
355
+
explode: true,
356
+
style: 'form'
357
+
}
358
+
}
359
+
}
360
+
},
351
361
responseType: 'json',
352
362
url: '/api/v{api-version}/complex',
353
363
...options
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/fetch/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/fetch/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/fetch/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/fetch/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/fetch/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/fetch/sdk.gen.ts
···
337
337
338
338
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
339
339
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
340
+
querySerializer: {
341
+
parameters: {
342
+
parameterObject: {
343
+
object: {
344
+
explode: true,
345
+
style: 'form'
346
+
}
347
+
}
348
+
}
349
+
},
340
350
url: '/api/v{api-version}/complex',
341
351
...options
342
352
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/name-builder/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/name-builder/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/name-builder/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/name-builder/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/asClass/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/asClass/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/asClass/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/asClass/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/axios/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/axios/client/utils.gen.ts
···
14
14
allowReserved,
15
15
array,
16
16
object,
17
+
parameters = {},
17
18
}: QuerySerializerOptions = {}) => {
18
19
const querySerializer = (queryParams: T) => {
19
20
const search: string[] = [];
···
25
26
continue;
26
27
}
27
28
29
+
// Get parameter-specific settings or fall back to global
30
+
const paramConfig = parameters[name] || {};
31
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
32
+
28
33
if (Array.isArray(value)) {
29
34
const serializedArray = serializeArrayParam({
30
-
allowReserved,
35
+
allowReserved: paramAllowReserved,
31
36
explode: true,
32
37
name,
33
38
style: 'form',
34
39
value,
35
40
...array,
41
+
...paramConfig.array,
36
42
});
37
43
if (serializedArray) search.push(serializedArray);
38
44
} else if (typeof value === 'object') {
39
45
const serializedObject = serializeObjectParam({
40
-
allowReserved,
46
+
allowReserved: paramAllowReserved,
41
47
explode: true,
42
48
name,
43
49
style: 'deepObject',
44
50
value: value as Record<string, unknown>,
45
51
...object,
52
+
...paramConfig.object,
46
53
});
47
54
if (serializedObject) search.push(serializedObject);
48
55
} else {
49
56
const serializedPrimitive = serializePrimitiveParam({
50
-
allowReserved,
57
+
allowReserved: paramAllowReserved,
51
58
name,
52
59
value: value as string,
53
60
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/axios/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/axios/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/axios/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/axios/sdk.gen.ts
···
348
348
349
349
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
350
350
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
351
+
querySerializer: {
352
+
parameters: {
353
+
parameterObject: {
354
+
object: {
355
+
explode: true,
356
+
style: 'form'
357
+
}
358
+
}
359
+
}
360
+
},
351
361
responseType: 'json',
352
362
url: '/api/v{api-version}/complex',
353
363
...options
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/fetch/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/fetch/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/fetch/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/fetch/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/fetch/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/fetch/sdk.gen.ts
···
337
337
338
338
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
339
339
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
340
+
querySerializer: {
341
+
parameters: {
342
+
parameterObject: {
343
+
object: {
344
+
explode: true,
345
+
style: 'form'
346
+
}
347
+
}
348
+
}
349
+
},
340
350
url: '/api/v{api-version}/complex',
341
351
...options
342
352
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/name-builder/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/name-builder/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/name-builder/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/name-builder/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/asClass/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/asClass/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/asClass/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/asClass/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/axios/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/axios/client/utils.gen.ts
···
14
14
allowReserved,
15
15
array,
16
16
object,
17
+
parameters = {},
17
18
}: QuerySerializerOptions = {}) => {
18
19
const querySerializer = (queryParams: T) => {
19
20
const search: string[] = [];
···
25
26
continue;
26
27
}
27
28
29
+
// Get parameter-specific settings or fall back to global
30
+
const paramConfig = parameters[name] || {};
31
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
32
+
28
33
if (Array.isArray(value)) {
29
34
const serializedArray = serializeArrayParam({
30
-
allowReserved,
35
+
allowReserved: paramAllowReserved,
31
36
explode: true,
32
37
name,
33
38
style: 'form',
34
39
value,
35
40
...array,
41
+
...paramConfig.array,
36
42
});
37
43
if (serializedArray) search.push(serializedArray);
38
44
} else if (typeof value === 'object') {
39
45
const serializedObject = serializeObjectParam({
40
-
allowReserved,
46
+
allowReserved: paramAllowReserved,
41
47
explode: true,
42
48
name,
43
49
style: 'deepObject',
44
50
value: value as Record<string, unknown>,
45
51
...object,
52
+
...paramConfig.object,
46
53
});
47
54
if (serializedObject) search.push(serializedObject);
48
55
} else {
49
56
const serializedPrimitive = serializePrimitiveParam({
50
-
allowReserved,
57
+
allowReserved: paramAllowReserved,
51
58
name,
52
59
value: value as string,
53
60
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/axios/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/axios/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/axios/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/axios/sdk.gen.ts
···
348
348
349
349
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
350
350
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
351
+
querySerializer: {
352
+
parameters: {
353
+
parameterObject: {
354
+
object: {
355
+
explode: true,
356
+
style: 'form'
357
+
}
358
+
}
359
+
}
360
+
},
351
361
responseType: 'json',
352
362
url: '/api/v{api-version}/complex',
353
363
...options
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/fetch/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/fetch/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/fetch/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/fetch/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/fetch/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/fetch/sdk.gen.ts
···
337
337
338
338
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
339
339
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
340
+
querySerializer: {
341
+
parameters: {
342
+
parameterObject: {
343
+
object: {
344
+
explode: true,
345
+
style: 'form'
346
+
}
347
+
}
348
+
}
349
+
},
340
350
url: '/api/v{api-version}/complex',
341
351
...options
342
352
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/name-builder/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/name-builder/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/name-builder/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/name-builder/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-api-key/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-api-key/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-api-key/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-api-key/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-false/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-false/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-false/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-false/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-http-bearer/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-http-bearer/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-http-bearer/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-http-bearer/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-oauth2/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-oauth2/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-oauth2/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-oauth2/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-open-id-connect/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-open-id-connect/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-open-id-connect/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-open-id-connect/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/servers/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/servers/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/servers/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/servers/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/transformers-all-of/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/transformers-all-of/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/transformers-all-of/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/transformers-all-of/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/transformers-any-of-null/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/transformers-any-of-null/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/transformers-any-of-null/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/transformers-any-of-null/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/transformers-array/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/transformers-array/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/transformers-array/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/transformers-array/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/transforms-read-write/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/transforms-read-write/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/transforms-read-write/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/transforms-read-write/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/body-response-text-plain/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/body-response-text-plain/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/body-response-text-plain/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/body-response-text-plain/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/content-types/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/content-types/client/utils.gen.ts
···
14
14
allowReserved,
15
15
array,
16
16
object,
17
+
parameters = {},
17
18
}: QuerySerializerOptions = {}) => {
18
19
const querySerializer = (queryParams: T) => {
19
20
const search: string[] = [];
···
25
26
continue;
26
27
}
27
28
29
+
// Get parameter-specific settings or fall back to global
30
+
const paramConfig = parameters[name] || {};
31
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
32
+
28
33
if (Array.isArray(value)) {
29
34
const serializedArray = serializeArrayParam({
30
-
allowReserved,
35
+
allowReserved: paramAllowReserved,
31
36
explode: true,
32
37
name,
33
38
style: 'form',
34
39
value,
35
40
...array,
41
+
...paramConfig.array,
36
42
});
37
43
if (serializedArray) search.push(serializedArray);
38
44
} else if (typeof value === 'object') {
39
45
const serializedObject = serializeObjectParam({
40
-
allowReserved,
46
+
allowReserved: paramAllowReserved,
41
47
explode: true,
42
48
name,
43
49
style: 'deepObject',
44
50
value: value as Record<string, unknown>,
45
51
...object,
52
+
...paramConfig.object,
46
53
});
47
54
if (serializedObject) search.push(serializedObject);
48
55
} else {
49
56
const serializedPrimitive = serializePrimitiveParam({
50
-
allowReserved,
57
+
allowReserved: paramAllowReserved,
51
58
name,
52
59
value: value as string,
53
60
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/content-types/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/content-types/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/headers/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/headers/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/headers/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/headers/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/internal-name-conflict/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/internal-name-conflict/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/internal-name-conflict/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/internal-name-conflict/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/pagination-ref/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/pagination-ref/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/pagination-ref/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/pagination-ref/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/parameter-explode-false-axios/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/parameter-explode-false-axios/client/utils.gen.ts
···
14
14
allowReserved,
15
15
array,
16
16
object,
17
+
parameters = {},
17
18
}: QuerySerializerOptions = {}) => {
18
19
const querySerializer = (queryParams: T) => {
19
20
const search: string[] = [];
···
25
26
continue;
26
27
}
27
28
29
+
// Get parameter-specific settings or fall back to global
30
+
const paramConfig = parameters[name] || {};
31
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
32
+
28
33
if (Array.isArray(value)) {
29
34
const serializedArray = serializeArrayParam({
30
-
allowReserved,
35
+
allowReserved: paramAllowReserved,
31
36
explode: true,
32
37
name,
33
38
style: 'form',
34
39
value,
35
40
...array,
41
+
...paramConfig.array,
36
42
});
37
43
if (serializedArray) search.push(serializedArray);
38
44
} else if (typeof value === 'object') {
39
45
const serializedObject = serializeObjectParam({
40
-
allowReserved,
46
+
allowReserved: paramAllowReserved,
41
47
explode: true,
42
48
name,
43
49
style: 'deepObject',
44
50
value: value as Record<string, unknown>,
45
51
...object,
52
+
...paramConfig.object,
46
53
});
47
54
if (serializedObject) search.push(serializedObject);
48
55
} else {
49
56
const serializedPrimitive = serializePrimitiveParam({
50
-
allowReserved,
57
+
allowReserved: paramAllowReserved,
51
58
name,
52
59
value: value as string,
53
60
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/parameter-explode-false-axios/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/parameter-explode-false-axios/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+7
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/parameter-explode-false-axios/sdk.gen.ts
+7
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/parameter-explode-false-axios/sdk.gen.ts
···
21
21
export const postFoo = <ThrowOnError extends boolean = false>(options?: Options<PostFooData, ThrowOnError>) => {
22
22
return (options?.client ?? client).post<PostFooResponses, unknown, ThrowOnError>({
23
23
querySerializer: {
24
-
array: {
25
-
explode: false,
26
-
style: 'form'
24
+
parameters: {
25
+
foo: {
26
+
array: {
27
+
explode: false,
28
+
style: 'form'
29
+
}
30
+
}
27
31
}
28
32
},
29
33
url: '/foo',
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/parameter-explode-false/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/parameter-explode-false/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/parameter-explode-false/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/parameter-explode-false/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+7
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/parameter-explode-false/sdk.gen.ts
+7
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/parameter-explode-false/sdk.gen.ts
···
21
21
export const postFoo = <ThrowOnError extends boolean = false>(options?: Options<PostFooData, ThrowOnError>) => {
22
22
return (options?.client ?? client).post<PostFooResponses, unknown, ThrowOnError>({
23
23
querySerializer: {
24
-
array: {
25
-
explode: false,
26
-
style: 'form'
24
+
parameters: {
25
+
foo: {
26
+
array: {
27
+
explode: false,
28
+
style: 'form'
29
+
}
30
+
}
27
31
}
28
32
},
29
33
url: '/foo',
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@angular/common/default-class/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@angular/common/default-class/client/utils.gen.ts
···
99
99
allowReserved,
100
100
array,
101
101
object,
102
+
parameters = {},
102
103
}: QuerySerializerOptions = {}) => {
103
104
const querySerializer = (queryParams: T) => {
104
105
const search: string[] = [];
···
110
111
continue;
111
112
}
112
113
114
+
// Get parameter-specific settings or fall back to global
115
+
const paramConfig = parameters[name] || {};
116
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
117
+
113
118
if (Array.isArray(value)) {
114
119
const serializedArray = serializeArrayParam({
115
-
allowReserved,
120
+
allowReserved: paramAllowReserved,
116
121
explode: true,
117
122
name,
118
123
style: 'form',
119
124
value,
120
125
...array,
126
+
...paramConfig.array,
121
127
});
122
128
if (serializedArray) search.push(serializedArray);
123
129
} else if (typeof value === 'object') {
124
130
const serializedObject = serializeObjectParam({
125
-
allowReserved,
131
+
allowReserved: paramAllowReserved,
126
132
explode: true,
127
133
name,
128
134
style: 'deepObject',
129
135
value: value as Record<string, unknown>,
130
136
...object,
137
+
...paramConfig.object,
131
138
});
132
139
if (serializedObject) search.push(serializedObject);
133
140
} else {
134
141
const serializedPrimitive = serializePrimitiveParam({
135
-
allowReserved,
142
+
allowReserved: paramAllowReserved,
136
143
name,
137
144
value: value as string,
138
145
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@angular/common/default-class/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@angular/common/default-class/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@angular/common/default-class/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@angular/common/default-class/sdk.gen.ts
···
337
337
338
338
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
339
339
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
340
+
querySerializer: {
341
+
parameters: {
342
+
parameterObject: {
343
+
object: {
344
+
explode: true,
345
+
style: 'form'
346
+
}
347
+
}
348
+
}
349
+
},
340
350
url: '/api/v{api-version}/complex',
341
351
...options
342
352
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@angular/common/default/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@angular/common/default/client/utils.gen.ts
···
99
99
allowReserved,
100
100
array,
101
101
object,
102
+
parameters = {},
102
103
}: QuerySerializerOptions = {}) => {
103
104
const querySerializer = (queryParams: T) => {
104
105
const search: string[] = [];
···
110
111
continue;
111
112
}
112
113
114
+
// Get parameter-specific settings or fall back to global
115
+
const paramConfig = parameters[name] || {};
116
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
117
+
113
118
if (Array.isArray(value)) {
114
119
const serializedArray = serializeArrayParam({
115
-
allowReserved,
120
+
allowReserved: paramAllowReserved,
116
121
explode: true,
117
122
name,
118
123
style: 'form',
119
124
value,
120
125
...array,
126
+
...paramConfig.array,
121
127
});
122
128
if (serializedArray) search.push(serializedArray);
123
129
} else if (typeof value === 'object') {
124
130
const serializedObject = serializeObjectParam({
125
-
allowReserved,
131
+
allowReserved: paramAllowReserved,
126
132
explode: true,
127
133
name,
128
134
style: 'deepObject',
129
135
value: value as Record<string, unknown>,
130
136
...object,
137
+
...paramConfig.object,
131
138
});
132
139
if (serializedObject) search.push(serializedObject);
133
140
} else {
134
141
const serializedPrimitive = serializePrimitiveParam({
135
-
allowReserved,
142
+
allowReserved: paramAllowReserved,
136
143
name,
137
144
value: value as string,
138
145
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@angular/common/default/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@angular/common/default/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@angular/common/default/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@angular/common/default/sdk.gen.ts
···
337
337
338
338
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
339
339
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
340
+
querySerializer: {
341
+
parameters: {
342
+
parameterObject: {
343
+
object: {
344
+
explode: true,
345
+
style: 'form'
346
+
}
347
+
}
348
+
}
349
+
},
340
350
url: '/api/v{api-version}/complex',
341
351
...options
342
352
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/client-fetch/sdk-nested-classes-instance/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/client-fetch/sdk-nested-classes-instance/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/client-fetch/sdk-nested-classes-instance/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/client-fetch/sdk-nested-classes-instance/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/client-fetch/sdk-nested-classes/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/client-fetch/sdk-nested-classes/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/client-fetch/sdk-nested-classes/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/client-fetch/sdk-nested-classes/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/sdk/default/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/sdk/default/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/sdk/default/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/sdk/default/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/sdk/default/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/sdk/default/sdk.gen.ts
···
337
337
338
338
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
339
339
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
340
+
querySerializer: {
341
+
parameters: {
342
+
parameterObject: {
343
+
object: {
344
+
explode: true,
345
+
style: 'form'
346
+
}
347
+
}
348
+
}
349
+
},
340
350
url: '/api/v{api-version}/complex',
341
351
...options
342
352
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/sdk/instance/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/sdk/instance/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/sdk/instance/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/sdk/instance/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/sdk/throwOnError/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/sdk/throwOnError/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/sdk/throwOnError/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/sdk/throwOnError/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/sdk/throwOnError/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/sdk/throwOnError/sdk.gen.ts
···
337
337
338
338
export const complexTypes = <ThrowOnError extends boolean = true>(options: Options<ComplexTypesData, ThrowOnError>) => {
339
339
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
340
+
querySerializer: {
341
+
parameters: {
342
+
parameterObject: {
343
+
object: {
344
+
explode: true,
345
+
style: 'form'
346
+
}
347
+
}
348
+
}
349
+
},
340
350
url: '/api/v{api-version}/complex',
341
351
...options
342
352
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/transformers/type-format-valibot/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/transformers/type-format-valibot/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/transformers/type-format-valibot/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/transformers/type-format-valibot/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/transformers/type-format-zod/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/transformers/type-format-zod/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/transformers/type-format-zod/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/transformers/type-format-zod/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/typescript/transforms-read-write-custom-name/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/typescript/transforms-read-write-custom-name/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/typescript/transforms-read-write-custom-name/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/typescript/transforms-read-write-custom-name/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/typescript/transforms-read-write-ignore/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/typescript/transforms-read-write-ignore/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/typescript/transforms-read-write-ignore/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/typescript/transforms-read-write-ignore/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@pinia/colada/asClass/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@pinia/colada/asClass/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@pinia/colada/asClass/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@pinia/colada/asClass/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@pinia/colada/fetch/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@pinia/colada/fetch/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@pinia/colada/fetch/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@pinia/colada/fetch/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@pinia/colada/fetch/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@pinia/colada/fetch/sdk.gen.ts
···
337
337
338
338
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
339
339
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
340
+
querySerializer: {
341
+
parameters: {
342
+
parameterObject: {
343
+
object: {
344
+
explode: true,
345
+
style: 'form'
346
+
}
347
+
}
348
+
}
349
+
},
340
350
url: '/api/v{api-version}/complex',
341
351
...options
342
352
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/asClass/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/asClass/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/asClass/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/asClass/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/axios/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/axios/client/utils.gen.ts
···
14
14
allowReserved,
15
15
array,
16
16
object,
17
+
parameters = {},
17
18
}: QuerySerializerOptions = {}) => {
18
19
const querySerializer = (queryParams: T) => {
19
20
const search: string[] = [];
···
25
26
continue;
26
27
}
27
28
29
+
// Get parameter-specific settings or fall back to global
30
+
const paramConfig = parameters[name] || {};
31
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
32
+
28
33
if (Array.isArray(value)) {
29
34
const serializedArray = serializeArrayParam({
30
-
allowReserved,
35
+
allowReserved: paramAllowReserved,
31
36
explode: true,
32
37
name,
33
38
style: 'form',
34
39
value,
35
40
...array,
41
+
...paramConfig.array,
36
42
});
37
43
if (serializedArray) search.push(serializedArray);
38
44
} else if (typeof value === 'object') {
39
45
const serializedObject = serializeObjectParam({
40
-
allowReserved,
46
+
allowReserved: paramAllowReserved,
41
47
explode: true,
42
48
name,
43
49
style: 'deepObject',
44
50
value: value as Record<string, unknown>,
45
51
...object,
52
+
...paramConfig.object,
46
53
});
47
54
if (serializedObject) search.push(serializedObject);
48
55
} else {
49
56
const serializedPrimitive = serializePrimitiveParam({
50
-
allowReserved,
57
+
allowReserved: paramAllowReserved,
51
58
name,
52
59
value: value as string,
53
60
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/axios/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/axios/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/axios/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/axios/sdk.gen.ts
···
348
348
349
349
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
350
350
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
351
+
querySerializer: {
352
+
parameters: {
353
+
parameterObject: {
354
+
object: {
355
+
explode: true,
356
+
style: 'form'
357
+
}
358
+
}
359
+
}
360
+
},
351
361
responseType: 'json',
352
362
url: '/api/v{api-version}/complex',
353
363
...options
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/fetch/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/fetch/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/fetch/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/fetch/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/fetch/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/fetch/sdk.gen.ts
···
337
337
338
338
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
339
339
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
340
+
querySerializer: {
341
+
parameters: {
342
+
parameterObject: {
343
+
object: {
344
+
explode: true,
345
+
style: 'form'
346
+
}
347
+
}
348
+
}
349
+
},
340
350
url: '/api/v{api-version}/complex',
341
351
...options
342
352
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/name-builder/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/name-builder/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/name-builder/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/name-builder/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/asClass/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/asClass/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/asClass/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/asClass/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/axios/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/axios/client/utils.gen.ts
···
14
14
allowReserved,
15
15
array,
16
16
object,
17
+
parameters = {},
17
18
}: QuerySerializerOptions = {}) => {
18
19
const querySerializer = (queryParams: T) => {
19
20
const search: string[] = [];
···
25
26
continue;
26
27
}
27
28
29
+
// Get parameter-specific settings or fall back to global
30
+
const paramConfig = parameters[name] || {};
31
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
32
+
28
33
if (Array.isArray(value)) {
29
34
const serializedArray = serializeArrayParam({
30
-
allowReserved,
35
+
allowReserved: paramAllowReserved,
31
36
explode: true,
32
37
name,
33
38
style: 'form',
34
39
value,
35
40
...array,
41
+
...paramConfig.array,
36
42
});
37
43
if (serializedArray) search.push(serializedArray);
38
44
} else if (typeof value === 'object') {
39
45
const serializedObject = serializeObjectParam({
40
-
allowReserved,
46
+
allowReserved: paramAllowReserved,
41
47
explode: true,
42
48
name,
43
49
style: 'deepObject',
44
50
value: value as Record<string, unknown>,
45
51
...object,
52
+
...paramConfig.object,
46
53
});
47
54
if (serializedObject) search.push(serializedObject);
48
55
} else {
49
56
const serializedPrimitive = serializePrimitiveParam({
50
-
allowReserved,
57
+
allowReserved: paramAllowReserved,
51
58
name,
52
59
value: value as string,
53
60
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/axios/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/axios/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/axios/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/axios/sdk.gen.ts
···
348
348
349
349
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
350
350
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
351
+
querySerializer: {
352
+
parameters: {
353
+
parameterObject: {
354
+
object: {
355
+
explode: true,
356
+
style: 'form'
357
+
}
358
+
}
359
+
}
360
+
},
351
361
responseType: 'json',
352
362
url: '/api/v{api-version}/complex',
353
363
...options
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/fetch/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/fetch/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/fetch/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/fetch/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/fetch/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/fetch/sdk.gen.ts
···
337
337
338
338
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
339
339
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
340
+
querySerializer: {
341
+
parameters: {
342
+
parameterObject: {
343
+
object: {
344
+
explode: true,
345
+
style: 'form'
346
+
}
347
+
}
348
+
}
349
+
},
340
350
url: '/api/v{api-version}/complex',
341
351
...options
342
352
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/name-builder/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/name-builder/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/name-builder/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/name-builder/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/asClass/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/asClass/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/asClass/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/asClass/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/axios/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/axios/client/utils.gen.ts
···
14
14
allowReserved,
15
15
array,
16
16
object,
17
+
parameters = {},
17
18
}: QuerySerializerOptions = {}) => {
18
19
const querySerializer = (queryParams: T) => {
19
20
const search: string[] = [];
···
25
26
continue;
26
27
}
27
28
29
+
// Get parameter-specific settings or fall back to global
30
+
const paramConfig = parameters[name] || {};
31
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
32
+
28
33
if (Array.isArray(value)) {
29
34
const serializedArray = serializeArrayParam({
30
-
allowReserved,
35
+
allowReserved: paramAllowReserved,
31
36
explode: true,
32
37
name,
33
38
style: 'form',
34
39
value,
35
40
...array,
41
+
...paramConfig.array,
36
42
});
37
43
if (serializedArray) search.push(serializedArray);
38
44
} else if (typeof value === 'object') {
39
45
const serializedObject = serializeObjectParam({
40
-
allowReserved,
46
+
allowReserved: paramAllowReserved,
41
47
explode: true,
42
48
name,
43
49
style: 'deepObject',
44
50
value: value as Record<string, unknown>,
45
51
...object,
52
+
...paramConfig.object,
46
53
});
47
54
if (serializedObject) search.push(serializedObject);
48
55
} else {
49
56
const serializedPrimitive = serializePrimitiveParam({
50
-
allowReserved,
57
+
allowReserved: paramAllowReserved,
51
58
name,
52
59
value: value as string,
53
60
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/axios/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/axios/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/axios/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/axios/sdk.gen.ts
···
348
348
349
349
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
350
350
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
351
+
querySerializer: {
352
+
parameters: {
353
+
parameterObject: {
354
+
object: {
355
+
explode: true,
356
+
style: 'form'
357
+
}
358
+
}
359
+
}
360
+
},
351
361
responseType: 'json',
352
362
url: '/api/v{api-version}/complex',
353
363
...options
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/fetch/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/fetch/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/fetch/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/fetch/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/fetch/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/fetch/sdk.gen.ts
···
337
337
338
338
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
339
339
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
340
+
querySerializer: {
341
+
parameters: {
342
+
parameterObject: {
343
+
object: {
344
+
explode: true,
345
+
style: 'form'
346
+
}
347
+
}
348
+
}
349
+
},
340
350
url: '/api/v{api-version}/complex',
341
351
...options
342
352
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/name-builder/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/name-builder/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/name-builder/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/name-builder/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/asClass/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/asClass/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/asClass/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/asClass/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/axios/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/axios/client/utils.gen.ts
···
14
14
allowReserved,
15
15
array,
16
16
object,
17
+
parameters = {},
17
18
}: QuerySerializerOptions = {}) => {
18
19
const querySerializer = (queryParams: T) => {
19
20
const search: string[] = [];
···
25
26
continue;
26
27
}
27
28
29
+
// Get parameter-specific settings or fall back to global
30
+
const paramConfig = parameters[name] || {};
31
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
32
+
28
33
if (Array.isArray(value)) {
29
34
const serializedArray = serializeArrayParam({
30
-
allowReserved,
35
+
allowReserved: paramAllowReserved,
31
36
explode: true,
32
37
name,
33
38
style: 'form',
34
39
value,
35
40
...array,
41
+
...paramConfig.array,
36
42
});
37
43
if (serializedArray) search.push(serializedArray);
38
44
} else if (typeof value === 'object') {
39
45
const serializedObject = serializeObjectParam({
40
-
allowReserved,
46
+
allowReserved: paramAllowReserved,
41
47
explode: true,
42
48
name,
43
49
style: 'deepObject',
44
50
value: value as Record<string, unknown>,
45
51
...object,
52
+
...paramConfig.object,
46
53
});
47
54
if (serializedObject) search.push(serializedObject);
48
55
} else {
49
56
const serializedPrimitive = serializePrimitiveParam({
50
-
allowReserved,
57
+
allowReserved: paramAllowReserved,
51
58
name,
52
59
value: value as string,
53
60
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/axios/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/axios/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/axios/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/axios/sdk.gen.ts
···
348
348
349
349
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
350
350
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
351
+
querySerializer: {
352
+
parameters: {
353
+
parameterObject: {
354
+
object: {
355
+
explode: true,
356
+
style: 'form'
357
+
}
358
+
}
359
+
}
360
+
},
351
361
responseType: 'json',
352
362
url: '/api/v{api-version}/complex',
353
363
...options
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/fetch/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/fetch/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/fetch/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/fetch/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/fetch/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/fetch/sdk.gen.ts
···
337
337
338
338
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
339
339
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
340
+
querySerializer: {
341
+
parameters: {
342
+
parameterObject: {
343
+
object: {
344
+
explode: true,
345
+
style: 'form'
346
+
}
347
+
}
348
+
}
349
+
},
340
350
url: '/api/v{api-version}/complex',
341
351
...options
342
352
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/name-builder/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/name-builder/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/name-builder/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/name-builder/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/asClass/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/asClass/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/asClass/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/asClass/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/axios/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/axios/client/utils.gen.ts
···
14
14
allowReserved,
15
15
array,
16
16
object,
17
+
parameters = {},
17
18
}: QuerySerializerOptions = {}) => {
18
19
const querySerializer = (queryParams: T) => {
19
20
const search: string[] = [];
···
25
26
continue;
26
27
}
27
28
29
+
// Get parameter-specific settings or fall back to global
30
+
const paramConfig = parameters[name] || {};
31
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
32
+
28
33
if (Array.isArray(value)) {
29
34
const serializedArray = serializeArrayParam({
30
-
allowReserved,
35
+
allowReserved: paramAllowReserved,
31
36
explode: true,
32
37
name,
33
38
style: 'form',
34
39
value,
35
40
...array,
41
+
...paramConfig.array,
36
42
});
37
43
if (serializedArray) search.push(serializedArray);
38
44
} else if (typeof value === 'object') {
39
45
const serializedObject = serializeObjectParam({
40
-
allowReserved,
46
+
allowReserved: paramAllowReserved,
41
47
explode: true,
42
48
name,
43
49
style: 'deepObject',
44
50
value: value as Record<string, unknown>,
45
51
...object,
52
+
...paramConfig.object,
46
53
});
47
54
if (serializedObject) search.push(serializedObject);
48
55
} else {
49
56
const serializedPrimitive = serializePrimitiveParam({
50
-
allowReserved,
57
+
allowReserved: paramAllowReserved,
51
58
name,
52
59
value: value as string,
53
60
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/axios/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/axios/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/axios/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/axios/sdk.gen.ts
···
348
348
349
349
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
350
350
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
351
+
querySerializer: {
352
+
parameters: {
353
+
parameterObject: {
354
+
object: {
355
+
explode: true,
356
+
style: 'form'
357
+
}
358
+
}
359
+
}
360
+
},
351
361
responseType: 'json',
352
362
url: '/api/v{api-version}/complex',
353
363
...options
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/fetch/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/fetch/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/fetch/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/fetch/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/fetch/sdk.gen.ts
+10
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/fetch/sdk.gen.ts
···
337
337
338
338
export const complexTypes = <ThrowOnError extends boolean = false>(options: Options<ComplexTypesData, ThrowOnError>) => {
339
339
return (options.client ?? client).get<ComplexTypesResponses, ComplexTypesErrors, ThrowOnError>({
340
+
querySerializer: {
341
+
parameters: {
342
+
parameterObject: {
343
+
object: {
344
+
explode: true,
345
+
style: 'form'
346
+
}
347
+
}
348
+
}
349
+
},
340
350
url: '/api/v{api-version}/complex',
341
351
...options
342
352
});
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/name-builder/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/name-builder/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/name-builder/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/name-builder/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-api-key/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-api-key/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-api-key/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-api-key/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-false/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-false/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-false/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-false/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-http-bearer/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-http-bearer/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-http-bearer/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-http-bearer/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-oauth2/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-oauth2/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-oauth2/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-oauth2/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-open-id-connect/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-open-id-connect/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-open-id-connect/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-open-id-connect/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/servers/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/servers/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/servers/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/servers/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-angular/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-angular/client/utils.gen.ts
···
99
99
allowReserved,
100
100
array,
101
101
object,
102
+
parameters = {},
102
103
}: QuerySerializerOptions = {}) => {
103
104
const querySerializer = (queryParams: T) => {
104
105
const search: string[] = [];
···
110
111
continue;
111
112
}
112
113
114
+
// Get parameter-specific settings or fall back to global
115
+
const paramConfig = parameters[name] || {};
116
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
117
+
113
118
if (Array.isArray(value)) {
114
119
const serializedArray = serializeArrayParam({
115
-
allowReserved,
120
+
allowReserved: paramAllowReserved,
116
121
explode: true,
117
122
name,
118
123
style: 'form',
119
124
value,
120
125
...array,
126
+
...paramConfig.array,
121
127
});
122
128
if (serializedArray) search.push(serializedArray);
123
129
} else if (typeof value === 'object') {
124
130
const serializedObject = serializeObjectParam({
125
-
allowReserved,
131
+
allowReserved: paramAllowReserved,
126
132
explode: true,
127
133
name,
128
134
style: 'deepObject',
129
135
value: value as Record<string, unknown>,
130
136
...object,
137
+
...paramConfig.object,
131
138
});
132
139
if (serializedObject) search.push(serializedObject);
133
140
} else {
134
141
const serializedPrimitive = serializePrimitiveParam({
135
-
allowReserved,
142
+
allowReserved: paramAllowReserved,
136
143
name,
137
144
value: value as string,
138
145
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-angular/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-angular/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-axios/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-axios/client/utils.gen.ts
···
14
14
allowReserved,
15
15
array,
16
16
object,
17
+
parameters = {},
17
18
}: QuerySerializerOptions = {}) => {
18
19
const querySerializer = (queryParams: T) => {
19
20
const search: string[] = [];
···
25
26
continue;
26
27
}
27
28
29
+
// Get parameter-specific settings or fall back to global
30
+
const paramConfig = parameters[name] || {};
31
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
32
+
28
33
if (Array.isArray(value)) {
29
34
const serializedArray = serializeArrayParam({
30
-
allowReserved,
35
+
allowReserved: paramAllowReserved,
31
36
explode: true,
32
37
name,
33
38
style: 'form',
34
39
value,
35
40
...array,
41
+
...paramConfig.array,
36
42
});
37
43
if (serializedArray) search.push(serializedArray);
38
44
} else if (typeof value === 'object') {
39
45
const serializedObject = serializeObjectParam({
40
-
allowReserved,
46
+
allowReserved: paramAllowReserved,
41
47
explode: true,
42
48
name,
43
49
style: 'deepObject',
44
50
value: value as Record<string, unknown>,
45
51
...object,
52
+
...paramConfig.object,
46
53
});
47
54
if (serializedObject) search.push(serializedObject);
48
55
} else {
49
56
const serializedPrimitive = serializePrimitiveParam({
50
-
allowReserved,
57
+
allowReserved: paramAllowReserved,
51
58
name,
52
59
value: value as string,
53
60
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-axios/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-axios/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-fetch/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-fetch/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-fetch/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-fetch/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-next/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-next/client/utils.gen.ts
···
98
98
allowReserved,
99
99
array,
100
100
object,
101
+
parameters = {},
101
102
}: QuerySerializerOptions = {}) => {
102
103
const querySerializer = (queryParams: T) => {
103
104
const search: string[] = [];
···
109
110
continue;
110
111
}
111
112
113
+
// Get parameter-specific settings or fall back to global
114
+
const paramConfig = parameters[name] || {};
115
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
116
+
112
117
if (Array.isArray(value)) {
113
118
const serializedArray = serializeArrayParam({
114
-
allowReserved,
119
+
allowReserved: paramAllowReserved,
115
120
explode: true,
116
121
name,
117
122
style: 'form',
118
123
value,
119
124
...array,
125
+
...paramConfig.array,
120
126
});
121
127
if (serializedArray) search.push(serializedArray);
122
128
} else if (typeof value === 'object') {
123
129
const serializedObject = serializeObjectParam({
124
-
allowReserved,
130
+
allowReserved: paramAllowReserved,
125
131
explode: true,
126
132
name,
127
133
style: 'deepObject',
128
134
value: value as Record<string, unknown>,
129
135
...object,
136
+
...paramConfig.object,
130
137
});
131
138
if (serializedObject) search.push(serializedObject);
132
139
} else {
133
140
const serializedPrimitive = serializePrimitiveParam({
134
-
allowReserved,
141
+
allowReserved: paramAllowReserved,
135
142
name,
136
143
value: value as string,
137
144
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-next/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-next/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-nuxt/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-nuxt/client/utils.gen.ts
···
103
103
allowReserved,
104
104
array,
105
105
object,
106
+
parameters = {},
106
107
}: QuerySerializerOptions = {}) => {
107
108
const querySerializer = (queryParams: T) => {
108
109
const search: string[] = [];
···
115
116
continue;
116
117
}
117
118
119
+
// Get parameter-specific settings or fall back to global
120
+
const paramConfig = parameters[name] || {};
121
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
122
+
118
123
if (Array.isArray(value)) {
119
124
const serializedArray = serializeArrayParam({
120
-
allowReserved,
125
+
allowReserved: paramAllowReserved,
121
126
explode: true,
122
127
name,
123
128
style: 'form',
124
129
value,
125
130
...array,
131
+
...paramConfig.array,
126
132
});
127
133
if (serializedArray) search.push(serializedArray);
128
134
} else if (typeof value === 'object') {
129
135
const serializedObject = serializeObjectParam({
130
-
allowReserved,
136
+
allowReserved: paramAllowReserved,
131
137
explode: true,
132
138
name,
133
139
style: 'deepObject',
134
140
value: value as Record<string, unknown>,
135
141
...object,
142
+
...paramConfig.object,
136
143
});
137
144
if (serializedObject) search.push(serializedObject);
138
145
} else {
139
146
const serializedPrimitive = serializePrimitiveParam({
140
-
allowReserved,
147
+
allowReserved: paramAllowReserved,
141
148
name,
142
149
value: value as string,
143
150
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-nuxt/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-nuxt/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-ofetch/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-ofetch/client/utils.gen.ts
···
27
27
allowReserved,
28
28
array,
29
29
object,
30
+
parameters = {},
30
31
}: QuerySerializerOptions = {}) => {
31
32
const querySerializer = (queryParams: T) => {
32
33
const search: string[] = [];
···
38
39
continue;
39
40
}
40
41
42
+
// Get parameter-specific settings or fall back to global
43
+
const paramConfig = parameters[name] || {};
44
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
45
+
41
46
if (Array.isArray(value)) {
42
47
const serializedArray = serializeArrayParam({
43
-
allowReserved,
48
+
allowReserved: paramAllowReserved,
44
49
explode: true,
45
50
name,
46
51
style: 'form',
47
52
value,
48
53
...array,
54
+
...paramConfig.array,
49
55
});
50
56
if (serializedArray) search.push(serializedArray);
51
57
} else if (typeof value === 'object') {
52
58
const serializedObject = serializeObjectParam({
53
-
allowReserved,
59
+
allowReserved: paramAllowReserved,
54
60
explode: true,
55
61
name,
56
62
style: 'deepObject',
57
63
value: value as Record<string, unknown>,
58
64
...object,
65
+
...paramConfig.object,
59
66
});
60
67
if (serializedObject) search.push(serializedObject);
61
68
} else {
62
69
const serializedPrimitive = serializePrimitiveParam({
63
-
allowReserved,
70
+
allowReserved: paramAllowReserved,
64
71
name,
65
72
value: value as string,
66
73
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-ofetch/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-ofetch/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/transformers-all-of/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/transformers-all-of/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/transformers-all-of/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/transformers-all-of/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/transformers-any-of-null/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/transformers-any-of-null/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/transformers-any-of-null/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/transformers-any-of-null/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/transformers-array/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/transformers-array/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/transformers-array/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/transformers-array/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/transforms-read-write/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/transforms-read-write/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/transforms-read-write/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/transforms-read-write/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/plugins/@tanstack/meta/client/utils.gen.ts
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/plugins/@tanstack/meta/client/utils.gen.ts
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/plugins/@tanstack/meta/core/bodySerializer.gen.ts
+12
packages/openapi-ts-tests/main/test/__snapshots__/plugins/@tanstack/meta/core/bodySerializer.gen.ts
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/test/generated/v3_no_index/client/utils.gen.ts.snap
+10
-3
packages/openapi-ts-tests/main/test/__snapshots__/test/generated/v3_no_index/client/utils.gen.ts.snap
···
15
15
allowReserved,
16
16
array,
17
17
object,
18
+
parameters = {},
18
19
}: QuerySerializerOptions = {}) => {
19
20
const querySerializer = (queryParams: T) => {
20
21
const search: string[] = [];
···
26
27
continue;
27
28
}
28
29
30
+
// Get parameter-specific settings or fall back to global
31
+
const paramConfig = parameters[name] || {};
32
+
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
29
34
if (Array.isArray(value)) {
30
35
const serializedArray = serializeArrayParam({
31
-
allowReserved,
36
+
allowReserved: paramAllowReserved,
32
37
explode: true,
33
38
name,
34
39
style: 'form',
35
40
value,
36
41
...array,
42
+
...paramConfig.array,
37
43
});
38
44
if (serializedArray) search.push(serializedArray);
39
45
} else if (typeof value === 'object') {
40
46
const serializedObject = serializeObjectParam({
41
-
allowReserved,
47
+
allowReserved: paramAllowReserved,
42
48
explode: true,
43
49
name,
44
50
style: 'deepObject',
45
51
value: value as Record<string, unknown>,
46
52
...object,
53
+
...paramConfig.object,
47
54
});
48
55
if (serializedObject) search.push(serializedObject);
49
56
} else {
50
57
const serializedPrimitive = serializePrimitiveParam({
51
-
allowReserved,
58
+
allowReserved: paramAllowReserved,
52
59
name,
53
60
value: value as string,
54
61
});
+12
packages/openapi-ts-tests/main/test/__snapshots__/test/generated/v3_no_index/core/bodySerializer.gen.ts.snap
+12
packages/openapi-ts-tests/main/test/__snapshots__/test/generated/v3_no_index/core/bodySerializer.gen.ts.snap
···
14
14
allowReserved?: boolean;
15
15
array?: SerializerOptions<ArrayStyle>;
16
16
object?: SerializerOptions<ObjectStyle>;
17
+
/**
18
+
* Per-parameter serialization overrides. When provided, these settings
19
+
* override the global array/object settings for specific parameter names.
20
+
*/
21
+
parameters?: Record<
22
+
string,
23
+
{
24
+
allowReserved?: boolean;
25
+
array?: SerializerOptions<ArrayStyle>;
26
+
object?: SerializerOptions<ObjectStyle>;
27
+
}
28
+
>;
17
29
}
18
30
19
31
const serializeFormDataPair = (