mokkenstorm.dev
fork of hey-api/openapi-ts because I need some additional things
chore: update examples
+7
-13
examples/openapi-ts-angular-common/src/client/client/utils.gen.ts
+7
-13
examples/openapi-ts-angular-common/src/client/client/utils.gen.ts
···
101
101
};
102
102
103
103
export const createQuerySerializer = <T = unknown>({
104
-
allowReserved,
105
-
array,
106
-
object,
107
104
parameters = {},
105
+
...args
108
106
}: QuerySerializerOptions = {}) => {
109
107
const querySerializer = (queryParams: T) => {
110
108
const search: string[] = [];
···
116
114
continue;
117
115
}
118
116
119
-
// Get parameter-specific settings or fall back to global
120
-
const paramConfig = parameters[name] || {};
121
-
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
117
+
const options = parameters[name] || args;
122
118
123
119
if (Array.isArray(value)) {
124
120
const serializedArray = serializeArrayParam({
125
-
allowReserved: paramAllowReserved,
121
+
allowReserved: options.allowReserved,
126
122
explode: true,
127
123
name,
128
124
style: 'form',
129
125
value,
130
-
...array,
131
-
...paramConfig.array,
126
+
...options.array,
132
127
});
133
128
if (serializedArray) search.push(serializedArray);
134
129
} else if (typeof value === 'object') {
135
130
const serializedObject = serializeObjectParam({
136
-
allowReserved: paramAllowReserved,
131
+
allowReserved: options.allowReserved,
137
132
explode: true,
138
133
name,
139
134
style: 'deepObject',
140
135
value: value as Record<string, unknown>,
141
-
...object,
142
-
...paramConfig.object,
136
+
...options.object,
143
137
});
144
138
if (serializedObject) search.push(serializedObject);
145
139
} else {
146
140
const serializedPrimitive = serializePrimitiveParam({
147
-
allowReserved: paramAllowReserved,
141
+
allowReserved: options.allowReserved,
148
142
name,
149
143
value: value as string,
150
144
});
+8
-12
examples/openapi-ts-angular-common/src/client/core/bodySerializer.gen.ts
+8
-12
examples/openapi-ts-angular-common/src/client/core/bodySerializer.gen.ts
···
10
10
11
11
export type BodySerializer = (body: any) => any;
12
12
13
-
export interface QuerySerializerOptions {
13
+
type QuerySerializerOptionsObject = {
14
14
allowReserved?: boolean;
15
-
array?: SerializerOptions<ArrayStyle>;
16
-
object?: SerializerOptions<ObjectStyle>;
15
+
array?: Partial<SerializerOptions<ArrayStyle>>;
16
+
object?: Partial<SerializerOptions<ObjectStyle>>;
17
+
};
18
+
19
+
export type QuerySerializerOptions = QuerySerializerOptionsObject & {
17
20
/**
18
21
* Per-parameter serialization overrides. When provided, these settings
19
22
* override the global array/object settings for specific parameter names.
20
23
*/
21
-
parameters?: Record<
22
-
string,
23
-
{
24
-
allowReserved?: boolean;
25
-
array?: SerializerOptions<ArrayStyle>;
26
-
object?: SerializerOptions<ObjectStyle>;
27
-
}
28
-
>;
29
-
}
24
+
parameters?: Record<string, QuerySerializerOptionsObject>;
25
+
};
30
26
31
27
const serializeFormDataPair = (
32
28
data: FormData,
+7
-13
examples/openapi-ts-angular/src/client/client/utils.gen.ts
+7
-13
examples/openapi-ts-angular/src/client/client/utils.gen.ts
···
101
101
};
102
102
103
103
export const createQuerySerializer = <T = unknown>({
104
-
allowReserved,
105
-
array,
106
-
object,
107
104
parameters = {},
105
+
...args
108
106
}: QuerySerializerOptions = {}) => {
109
107
const querySerializer = (queryParams: T) => {
110
108
const search: string[] = [];
···
116
114
continue;
117
115
}
118
116
119
-
// Get parameter-specific settings or fall back to global
120
-
const paramConfig = parameters[name] || {};
121
-
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
117
+
const options = parameters[name] || args;
122
118
123
119
if (Array.isArray(value)) {
124
120
const serializedArray = serializeArrayParam({
125
-
allowReserved: paramAllowReserved,
121
+
allowReserved: options.allowReserved,
126
122
explode: true,
127
123
name,
128
124
style: 'form',
129
125
value,
130
-
...array,
131
-
...paramConfig.array,
126
+
...options.array,
132
127
});
133
128
if (serializedArray) search.push(serializedArray);
134
129
} else if (typeof value === 'object') {
135
130
const serializedObject = serializeObjectParam({
136
-
allowReserved: paramAllowReserved,
131
+
allowReserved: options.allowReserved,
137
132
explode: true,
138
133
name,
139
134
style: 'deepObject',
140
135
value: value as Record<string, unknown>,
141
-
...object,
142
-
...paramConfig.object,
136
+
...options.object,
143
137
});
144
138
if (serializedObject) search.push(serializedObject);
145
139
} else {
146
140
const serializedPrimitive = serializePrimitiveParam({
147
-
allowReserved: paramAllowReserved,
141
+
allowReserved: options.allowReserved,
148
142
name,
149
143
value: value as string,
150
144
});
+8
-12
examples/openapi-ts-angular/src/client/core/bodySerializer.gen.ts
+8
-12
examples/openapi-ts-angular/src/client/core/bodySerializer.gen.ts
···
10
10
11
11
export type BodySerializer = (body: any) => any;
12
12
13
-
export interface QuerySerializerOptions {
13
+
type QuerySerializerOptionsObject = {
14
14
allowReserved?: boolean;
15
-
array?: SerializerOptions<ArrayStyle>;
16
-
object?: SerializerOptions<ObjectStyle>;
15
+
array?: Partial<SerializerOptions<ArrayStyle>>;
16
+
object?: Partial<SerializerOptions<ObjectStyle>>;
17
+
};
18
+
19
+
export type QuerySerializerOptions = QuerySerializerOptionsObject & {
17
20
/**
18
21
* Per-parameter serialization overrides. When provided, these settings
19
22
* override the global array/object settings for specific parameter names.
20
23
*/
21
-
parameters?: Record<
22
-
string,
23
-
{
24
-
allowReserved?: boolean;
25
-
array?: SerializerOptions<ArrayStyle>;
26
-
object?: SerializerOptions<ObjectStyle>;
27
-
}
28
-
>;
29
-
}
24
+
parameters?: Record<string, QuerySerializerOptionsObject>;
25
+
};
30
26
31
27
const serializeFormDataPair = (
32
28
data: FormData,
+7
-13
examples/openapi-ts-axios/src/client/client/utils.gen.ts
+7
-13
examples/openapi-ts-axios/src/client/client/utils.gen.ts
···
16
16
} from './types.gen';
17
17
18
18
export const createQuerySerializer = <T = unknown>({
19
-
allowReserved,
20
-
array,
21
-
object,
22
19
parameters = {},
20
+
...args
23
21
}: QuerySerializerOptions = {}) => {
24
22
const querySerializer = (queryParams: T) => {
25
23
const search: string[] = [];
···
31
29
continue;
32
30
}
33
31
34
-
// Get parameter-specific settings or fall back to global
35
-
const paramConfig = parameters[name] || {};
36
-
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
32
+
const options = parameters[name] || args;
37
33
38
34
if (Array.isArray(value)) {
39
35
const serializedArray = serializeArrayParam({
40
-
allowReserved: paramAllowReserved,
36
+
allowReserved: options.allowReserved,
41
37
explode: true,
42
38
name,
43
39
style: 'form',
44
40
value,
45
-
...array,
46
-
...paramConfig.array,
41
+
...options.array,
47
42
});
48
43
if (serializedArray) search.push(serializedArray);
49
44
} else if (typeof value === 'object') {
50
45
const serializedObject = serializeObjectParam({
51
-
allowReserved: paramAllowReserved,
46
+
allowReserved: options.allowReserved,
52
47
explode: true,
53
48
name,
54
49
style: 'deepObject',
55
50
value: value as Record<string, unknown>,
56
-
...object,
57
-
...paramConfig.object,
51
+
...options.object,
58
52
});
59
53
if (serializedObject) search.push(serializedObject);
60
54
} else {
61
55
const serializedPrimitive = serializePrimitiveParam({
62
-
allowReserved: paramAllowReserved,
56
+
allowReserved: options.allowReserved,
63
57
name,
64
58
value: value as string,
65
59
});
+8
-12
examples/openapi-ts-axios/src/client/core/bodySerializer.gen.ts
+8
-12
examples/openapi-ts-axios/src/client/core/bodySerializer.gen.ts
···
10
10
11
11
export type BodySerializer = (body: any) => any;
12
12
13
-
export interface QuerySerializerOptions {
13
+
type QuerySerializerOptionsObject = {
14
14
allowReserved?: boolean;
15
-
array?: SerializerOptions<ArrayStyle>;
16
-
object?: SerializerOptions<ObjectStyle>;
15
+
array?: Partial<SerializerOptions<ArrayStyle>>;
16
+
object?: Partial<SerializerOptions<ObjectStyle>>;
17
+
};
18
+
19
+
export type QuerySerializerOptions = QuerySerializerOptionsObject & {
17
20
/**
18
21
* Per-parameter serialization overrides. When provided, these settings
19
22
* override the global array/object settings for specific parameter names.
20
23
*/
21
-
parameters?: Record<
22
-
string,
23
-
{
24
-
allowReserved?: boolean;
25
-
array?: SerializerOptions<ArrayStyle>;
26
-
object?: SerializerOptions<ObjectStyle>;
27
-
}
28
-
>;
29
-
}
24
+
parameters?: Record<string, QuerySerializerOptionsObject>;
25
+
};
30
26
31
27
const serializeFormDataPair = (
32
28
data: FormData,
+7
-13
examples/openapi-ts-fastify/src/client/client/utils.gen.ts
+7
-13
examples/openapi-ts-fastify/src/client/client/utils.gen.ts
···
17
17
} from './types.gen';
18
18
19
19
export const createQuerySerializer = <T = unknown>({
20
-
allowReserved,
21
-
array,
22
-
object,
23
20
parameters = {},
21
+
...args
24
22
}: QuerySerializerOptions = {}) => {
25
23
const querySerializer = (queryParams: T) => {
26
24
const search: string[] = [];
···
32
30
continue;
33
31
}
34
32
35
-
// Get parameter-specific settings or fall back to global
36
-
const paramConfig = parameters[name] || {};
37
-
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
const options = parameters[name] || args;
38
34
39
35
if (Array.isArray(value)) {
40
36
const serializedArray = serializeArrayParam({
41
-
allowReserved: paramAllowReserved,
37
+
allowReserved: options.allowReserved,
42
38
explode: true,
43
39
name,
44
40
style: 'form',
45
41
value,
46
-
...array,
47
-
...paramConfig.array,
42
+
...options.array,
48
43
});
49
44
if (serializedArray) search.push(serializedArray);
50
45
} else if (typeof value === 'object') {
51
46
const serializedObject = serializeObjectParam({
52
-
allowReserved: paramAllowReserved,
47
+
allowReserved: options.allowReserved,
53
48
explode: true,
54
49
name,
55
50
style: 'deepObject',
56
51
value: value as Record<string, unknown>,
57
-
...object,
58
-
...paramConfig.object,
52
+
...options.object,
59
53
});
60
54
if (serializedObject) search.push(serializedObject);
61
55
} else {
62
56
const serializedPrimitive = serializePrimitiveParam({
63
-
allowReserved: paramAllowReserved,
57
+
allowReserved: options.allowReserved,
64
58
name,
65
59
value: value as string,
66
60
});
+8
-12
examples/openapi-ts-fastify/src/client/core/bodySerializer.gen.ts
+8
-12
examples/openapi-ts-fastify/src/client/core/bodySerializer.gen.ts
···
10
10
11
11
export type BodySerializer = (body: any) => any;
12
12
13
-
export interface QuerySerializerOptions {
13
+
type QuerySerializerOptionsObject = {
14
14
allowReserved?: boolean;
15
-
array?: SerializerOptions<ArrayStyle>;
16
-
object?: SerializerOptions<ObjectStyle>;
15
+
array?: Partial<SerializerOptions<ArrayStyle>>;
16
+
object?: Partial<SerializerOptions<ObjectStyle>>;
17
+
};
18
+
19
+
export type QuerySerializerOptions = QuerySerializerOptionsObject & {
17
20
/**
18
21
* Per-parameter serialization overrides. When provided, these settings
19
22
* override the global array/object settings for specific parameter names.
20
23
*/
21
-
parameters?: Record<
22
-
string,
23
-
{
24
-
allowReserved?: boolean;
25
-
array?: SerializerOptions<ArrayStyle>;
26
-
object?: SerializerOptions<ObjectStyle>;
27
-
}
28
-
>;
29
-
}
24
+
parameters?: Record<string, QuerySerializerOptionsObject>;
25
+
};
30
26
31
27
const serializeFormDataPair = (
32
28
data: FormData,
+7
-13
examples/openapi-ts-fetch/src/client/client/utils.gen.ts
+7
-13
examples/openapi-ts-fetch/src/client/client/utils.gen.ts
···
17
17
} from './types.gen';
18
18
19
19
export const createQuerySerializer = <T = unknown>({
20
-
allowReserved,
21
-
array,
22
-
object,
23
20
parameters = {},
21
+
...args
24
22
}: QuerySerializerOptions = {}) => {
25
23
const querySerializer = (queryParams: T) => {
26
24
const search: string[] = [];
···
32
30
continue;
33
31
}
34
32
35
-
// Get parameter-specific settings or fall back to global
36
-
const paramConfig = parameters[name] || {};
37
-
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
const options = parameters[name] || args;
38
34
39
35
if (Array.isArray(value)) {
40
36
const serializedArray = serializeArrayParam({
41
-
allowReserved: paramAllowReserved,
37
+
allowReserved: options.allowReserved,
42
38
explode: true,
43
39
name,
44
40
style: 'form',
45
41
value,
46
-
...array,
47
-
...paramConfig.array,
42
+
...options.array,
48
43
});
49
44
if (serializedArray) search.push(serializedArray);
50
45
} else if (typeof value === 'object') {
51
46
const serializedObject = serializeObjectParam({
52
-
allowReserved: paramAllowReserved,
47
+
allowReserved: options.allowReserved,
53
48
explode: true,
54
49
name,
55
50
style: 'deepObject',
56
51
value: value as Record<string, unknown>,
57
-
...object,
58
-
...paramConfig.object,
52
+
...options.object,
59
53
});
60
54
if (serializedObject) search.push(serializedObject);
61
55
} else {
62
56
const serializedPrimitive = serializePrimitiveParam({
63
-
allowReserved: paramAllowReserved,
57
+
allowReserved: options.allowReserved,
64
58
name,
65
59
value: value as string,
66
60
});
+8
-12
examples/openapi-ts-fetch/src/client/core/bodySerializer.gen.ts
+8
-12
examples/openapi-ts-fetch/src/client/core/bodySerializer.gen.ts
···
10
10
11
11
export type BodySerializer = (body: any) => any;
12
12
13
-
export interface QuerySerializerOptions {
13
+
type QuerySerializerOptionsObject = {
14
14
allowReserved?: boolean;
15
-
array?: SerializerOptions<ArrayStyle>;
16
-
object?: SerializerOptions<ObjectStyle>;
15
+
array?: Partial<SerializerOptions<ArrayStyle>>;
16
+
object?: Partial<SerializerOptions<ObjectStyle>>;
17
+
};
18
+
19
+
export type QuerySerializerOptions = QuerySerializerOptionsObject & {
17
20
/**
18
21
* Per-parameter serialization overrides. When provided, these settings
19
22
* override the global array/object settings for specific parameter names.
20
23
*/
21
-
parameters?: Record<
22
-
string,
23
-
{
24
-
allowReserved?: boolean;
25
-
array?: SerializerOptions<ArrayStyle>;
26
-
object?: SerializerOptions<ObjectStyle>;
27
-
}
28
-
>;
29
-
}
24
+
parameters?: Record<string, QuerySerializerOptionsObject>;
25
+
};
30
26
31
27
const serializeFormDataPair = (
32
28
data: FormData,
+7
-13
examples/openapi-ts-next/src/client/client/utils.gen.ts
+7
-13
examples/openapi-ts-next/src/client/client/utils.gen.ts
···
100
100
};
101
101
102
102
export const createQuerySerializer = <T = unknown>({
103
-
allowReserved,
104
-
array,
105
-
object,
106
103
parameters = {},
104
+
...args
107
105
}: QuerySerializerOptions = {}) => {
108
106
const querySerializer = (queryParams: T) => {
109
107
const search: string[] = [];
···
115
113
continue;
116
114
}
117
115
118
-
// Get parameter-specific settings or fall back to global
119
-
const paramConfig = parameters[name] || {};
120
-
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
116
+
const options = parameters[name] || args;
121
117
122
118
if (Array.isArray(value)) {
123
119
const serializedArray = serializeArrayParam({
124
-
allowReserved: paramAllowReserved,
120
+
allowReserved: options.allowReserved,
125
121
explode: true,
126
122
name,
127
123
style: 'form',
128
124
value,
129
-
...array,
130
-
...paramConfig.array,
125
+
...options.array,
131
126
});
132
127
if (serializedArray) search.push(serializedArray);
133
128
} else if (typeof value === 'object') {
134
129
const serializedObject = serializeObjectParam({
135
-
allowReserved: paramAllowReserved,
130
+
allowReserved: options.allowReserved,
136
131
explode: true,
137
132
name,
138
133
style: 'deepObject',
139
134
value: value as Record<string, unknown>,
140
-
...object,
141
-
...paramConfig.object,
135
+
...options.object,
142
136
});
143
137
if (serializedObject) search.push(serializedObject);
144
138
} else {
145
139
const serializedPrimitive = serializePrimitiveParam({
146
-
allowReserved: paramAllowReserved,
140
+
allowReserved: options.allowReserved,
147
141
name,
148
142
value: value as string,
149
143
});
+8
-12
examples/openapi-ts-next/src/client/core/bodySerializer.gen.ts
+8
-12
examples/openapi-ts-next/src/client/core/bodySerializer.gen.ts
···
10
10
11
11
export type BodySerializer = (body: any) => any;
12
12
13
-
export interface QuerySerializerOptions {
13
+
type QuerySerializerOptionsObject = {
14
14
allowReserved?: boolean;
15
-
array?: SerializerOptions<ArrayStyle>;
16
-
object?: SerializerOptions<ObjectStyle>;
15
+
array?: Partial<SerializerOptions<ArrayStyle>>;
16
+
object?: Partial<SerializerOptions<ObjectStyle>>;
17
+
};
18
+
19
+
export type QuerySerializerOptions = QuerySerializerOptionsObject & {
17
20
/**
18
21
* Per-parameter serialization overrides. When provided, these settings
19
22
* override the global array/object settings for specific parameter names.
20
23
*/
21
-
parameters?: Record<
22
-
string,
23
-
{
24
-
allowReserved?: boolean;
25
-
array?: SerializerOptions<ArrayStyle>;
26
-
object?: SerializerOptions<ObjectStyle>;
27
-
}
28
-
>;
29
-
}
24
+
parameters?: Record<string, QuerySerializerOptionsObject>;
25
+
};
30
26
31
27
const serializeFormDataPair = (
32
28
data: FormData,
+7
-13
examples/openapi-ts-ofetch/src/client/client/utils.gen.ts
+7
-13
examples/openapi-ts-ofetch/src/client/client/utils.gen.ts
···
24
24
} from './types.gen';
25
25
26
26
export const createQuerySerializer = <T = unknown>({
27
-
allowReserved,
28
-
array,
29
-
object,
30
27
parameters = {},
28
+
...args
31
29
}: QuerySerializerOptions = {}) => {
32
30
const querySerializer = (queryParams: T) => {
33
31
const search: string[] = [];
···
39
37
continue;
40
38
}
41
39
42
-
// Get parameter-specific settings or fall back to global
43
-
const paramConfig = parameters[name] || {};
44
-
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
40
+
const options = parameters[name] || args;
45
41
46
42
if (Array.isArray(value)) {
47
43
const serializedArray = serializeArrayParam({
48
-
allowReserved: paramAllowReserved,
44
+
allowReserved: options.allowReserved,
49
45
explode: true,
50
46
name,
51
47
style: 'form',
52
48
value,
53
-
...array,
54
-
...paramConfig.array,
49
+
...options.array,
55
50
});
56
51
if (serializedArray) search.push(serializedArray);
57
52
} else if (typeof value === 'object') {
58
53
const serializedObject = serializeObjectParam({
59
-
allowReserved: paramAllowReserved,
54
+
allowReserved: options.allowReserved,
60
55
explode: true,
61
56
name,
62
57
style: 'deepObject',
63
58
value: value as Record<string, unknown>,
64
-
...object,
65
-
...paramConfig.object,
59
+
...options.object,
66
60
});
67
61
if (serializedObject) search.push(serializedObject);
68
62
} else {
69
63
const serializedPrimitive = serializePrimitiveParam({
70
-
allowReserved: paramAllowReserved,
64
+
allowReserved: options.allowReserved,
71
65
name,
72
66
value: value as string,
73
67
});
+8
-12
examples/openapi-ts-ofetch/src/client/core/bodySerializer.gen.ts
+8
-12
examples/openapi-ts-ofetch/src/client/core/bodySerializer.gen.ts
···
10
10
11
11
export type BodySerializer = (body: any) => any;
12
12
13
-
export interface QuerySerializerOptions {
13
+
type QuerySerializerOptionsObject = {
14
14
allowReserved?: boolean;
15
-
array?: SerializerOptions<ArrayStyle>;
16
-
object?: SerializerOptions<ObjectStyle>;
15
+
array?: Partial<SerializerOptions<ArrayStyle>>;
16
+
object?: Partial<SerializerOptions<ObjectStyle>>;
17
+
};
18
+
19
+
export type QuerySerializerOptions = QuerySerializerOptionsObject & {
17
20
/**
18
21
* Per-parameter serialization overrides. When provided, these settings
19
22
* override the global array/object settings for specific parameter names.
20
23
*/
21
-
parameters?: Record<
22
-
string,
23
-
{
24
-
allowReserved?: boolean;
25
-
array?: SerializerOptions<ArrayStyle>;
26
-
object?: SerializerOptions<ObjectStyle>;
27
-
}
28
-
>;
29
-
}
24
+
parameters?: Record<string, QuerySerializerOptionsObject>;
25
+
};
30
26
31
27
const serializeFormDataPair = (
32
28
data: FormData,
+7
-13
examples/openapi-ts-openai/src/client/client/utils.gen.ts
+7
-13
examples/openapi-ts-openai/src/client/client/utils.gen.ts
···
17
17
} from './types.gen';
18
18
19
19
export const createQuerySerializer = <T = unknown>({
20
-
allowReserved,
21
-
array,
22
-
object,
23
20
parameters = {},
21
+
...args
24
22
}: QuerySerializerOptions = {}) => {
25
23
const querySerializer = (queryParams: T) => {
26
24
const search: string[] = [];
···
32
30
continue;
33
31
}
34
32
35
-
// Get parameter-specific settings or fall back to global
36
-
const paramConfig = parameters[name] || {};
37
-
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
const options = parameters[name] || args;
38
34
39
35
if (Array.isArray(value)) {
40
36
const serializedArray = serializeArrayParam({
41
-
allowReserved: paramAllowReserved,
37
+
allowReserved: options.allowReserved,
42
38
explode: true,
43
39
name,
44
40
style: 'form',
45
41
value,
46
-
...array,
47
-
...paramConfig.array,
42
+
...options.array,
48
43
});
49
44
if (serializedArray) search.push(serializedArray);
50
45
} else if (typeof value === 'object') {
51
46
const serializedObject = serializeObjectParam({
52
-
allowReserved: paramAllowReserved,
47
+
allowReserved: options.allowReserved,
53
48
explode: true,
54
49
name,
55
50
style: 'deepObject',
56
51
value: value as Record<string, unknown>,
57
-
...object,
58
-
...paramConfig.object,
52
+
...options.object,
59
53
});
60
54
if (serializedObject) search.push(serializedObject);
61
55
} else {
62
56
const serializedPrimitive = serializePrimitiveParam({
63
-
allowReserved: paramAllowReserved,
57
+
allowReserved: options.allowReserved,
64
58
name,
65
59
value: value as string,
66
60
});
+8
-12
examples/openapi-ts-openai/src/client/core/bodySerializer.gen.ts
+8
-12
examples/openapi-ts-openai/src/client/core/bodySerializer.gen.ts
···
10
10
11
11
export type BodySerializer = (body: any) => any;
12
12
13
-
export interface QuerySerializerOptions {
13
+
type QuerySerializerOptionsObject = {
14
14
allowReserved?: boolean;
15
-
array?: SerializerOptions<ArrayStyle>;
16
-
object?: SerializerOptions<ObjectStyle>;
15
+
array?: Partial<SerializerOptions<ArrayStyle>>;
16
+
object?: Partial<SerializerOptions<ObjectStyle>>;
17
+
};
18
+
19
+
export type QuerySerializerOptions = QuerySerializerOptionsObject & {
17
20
/**
18
21
* Per-parameter serialization overrides. When provided, these settings
19
22
* override the global array/object settings for specific parameter names.
20
23
*/
21
-
parameters?: Record<
22
-
string,
23
-
{
24
-
allowReserved?: boolean;
25
-
array?: SerializerOptions<ArrayStyle>;
26
-
object?: SerializerOptions<ObjectStyle>;
27
-
}
28
-
>;
29
-
}
24
+
parameters?: Record<string, QuerySerializerOptionsObject>;
25
+
};
30
26
31
27
const serializeFormDataPair = (
32
28
data: FormData,
-1
examples/openapi-ts-openai/src/client/sdk.gen.ts
-1
examples/openapi-ts-openai/src/client/sdk.gen.ts
+8
-14
examples/openapi-ts-pinia-colada/src/client/client/utils.gen.ts
+8
-14
examples/openapi-ts-pinia-colada/src/client/client/utils.gen.ts
···
12
12
import type { Client, ClientOptions, Config, RequestOptions } from './types.gen'
13
13
14
14
export const createQuerySerializer = <T = unknown>({
15
-
allowReserved,
16
-
array,
17
-
object,
18
-
parameters = {}
15
+
parameters = {},
16
+
...args
19
17
}: QuerySerializerOptions = {}) => {
20
18
const querySerializer = (queryParams: T) => {
21
19
const search: string[] = []
···
27
25
continue
28
26
}
29
27
30
-
// Get parameter-specific settings or fall back to global
31
-
const paramConfig = parameters[name] || {}
32
-
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved
28
+
const options = parameters[name] || args
33
29
34
30
if (Array.isArray(value)) {
35
31
const serializedArray = serializeArrayParam({
36
-
allowReserved: paramAllowReserved,
32
+
allowReserved: options.allowReserved,
37
33
explode: true,
38
34
name,
39
35
style: 'form',
40
36
value,
41
-
...array,
42
-
...paramConfig.array
37
+
...options.array
43
38
})
44
39
if (serializedArray) search.push(serializedArray)
45
40
} else if (typeof value === 'object') {
46
41
const serializedObject = serializeObjectParam({
47
-
allowReserved: paramAllowReserved,
42
+
allowReserved: options.allowReserved,
48
43
explode: true,
49
44
name,
50
45
style: 'deepObject',
51
46
value: value as Record<string, unknown>,
52
-
...object,
53
-
...paramConfig.object
47
+
...options.object
54
48
})
55
49
if (serializedObject) search.push(serializedObject)
56
50
} else {
57
51
const serializedPrimitive = serializePrimitiveParam({
58
-
allowReserved: paramAllowReserved,
52
+
allowReserved: options.allowReserved,
59
53
name,
60
54
value: value as string
61
55
})
+7
-11
examples/openapi-ts-pinia-colada/src/client/core/bodySerializer.gen.ts
+7
-11
examples/openapi-ts-pinia-colada/src/client/core/bodySerializer.gen.ts
···
6
6
7
7
export type BodySerializer = (body: any) => any
8
8
9
-
export interface QuerySerializerOptions {
9
+
type QuerySerializerOptionsObject = {
10
10
allowReserved?: boolean
11
-
array?: SerializerOptions<ArrayStyle>
12
-
object?: SerializerOptions<ObjectStyle>
11
+
array?: Partial<SerializerOptions<ArrayStyle>>
12
+
object?: Partial<SerializerOptions<ObjectStyle>>
13
+
}
14
+
15
+
export type QuerySerializerOptions = QuerySerializerOptionsObject & {
13
16
/**
14
17
* Per-parameter serialization overrides. When provided, these settings
15
18
* override the global array/object settings for specific parameter names.
16
19
*/
17
-
parameters?: Record<
18
-
string,
19
-
{
20
-
allowReserved?: boolean
21
-
array?: SerializerOptions<ArrayStyle>
22
-
object?: SerializerOptions<ObjectStyle>
23
-
}
24
-
>
20
+
parameters?: Record<string, QuerySerializerOptionsObject>
25
21
}
26
22
27
23
const serializeFormDataPair = (data: FormData, key: string, value: unknown): void => {
+7
-13
examples/openapi-ts-sample/src/client/client/utils.gen.ts
+7
-13
examples/openapi-ts-sample/src/client/client/utils.gen.ts
···
17
17
} from './types.gen';
18
18
19
19
export const createQuerySerializer = <T = unknown>({
20
-
allowReserved,
21
-
array,
22
-
object,
23
20
parameters = {},
21
+
...args
24
22
}: QuerySerializerOptions = {}) => {
25
23
const querySerializer = (queryParams: T) => {
26
24
const search: string[] = [];
···
32
30
continue;
33
31
}
34
32
35
-
// Get parameter-specific settings or fall back to global
36
-
const paramConfig = parameters[name] || {};
37
-
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
const options = parameters[name] || args;
38
34
39
35
if (Array.isArray(value)) {
40
36
const serializedArray = serializeArrayParam({
41
-
allowReserved: paramAllowReserved,
37
+
allowReserved: options.allowReserved,
42
38
explode: true,
43
39
name,
44
40
style: 'form',
45
41
value,
46
-
...array,
47
-
...paramConfig.array,
42
+
...options.array,
48
43
});
49
44
if (serializedArray) search.push(serializedArray);
50
45
} else if (typeof value === 'object') {
51
46
const serializedObject = serializeObjectParam({
52
-
allowReserved: paramAllowReserved,
47
+
allowReserved: options.allowReserved,
53
48
explode: true,
54
49
name,
55
50
style: 'deepObject',
56
51
value: value as Record<string, unknown>,
57
-
...object,
58
-
...paramConfig.object,
52
+
...options.object,
59
53
});
60
54
if (serializedObject) search.push(serializedObject);
61
55
} else {
62
56
const serializedPrimitive = serializePrimitiveParam({
63
-
allowReserved: paramAllowReserved,
57
+
allowReserved: options.allowReserved,
64
58
name,
65
59
value: value as string,
66
60
});
+8
-12
examples/openapi-ts-sample/src/client/core/bodySerializer.gen.ts
+8
-12
examples/openapi-ts-sample/src/client/core/bodySerializer.gen.ts
···
10
10
11
11
export type BodySerializer = (body: any) => any;
12
12
13
-
export interface QuerySerializerOptions {
13
+
type QuerySerializerOptionsObject = {
14
14
allowReserved?: boolean;
15
-
array?: SerializerOptions<ArrayStyle>;
16
-
object?: SerializerOptions<ObjectStyle>;
15
+
array?: Partial<SerializerOptions<ArrayStyle>>;
16
+
object?: Partial<SerializerOptions<ObjectStyle>>;
17
+
};
18
+
19
+
export type QuerySerializerOptions = QuerySerializerOptionsObject & {
17
20
/**
18
21
* Per-parameter serialization overrides. When provided, these settings
19
22
* override the global array/object settings for specific parameter names.
20
23
*/
21
-
parameters?: Record<
22
-
string,
23
-
{
24
-
allowReserved?: boolean;
25
-
array?: SerializerOptions<ArrayStyle>;
26
-
object?: SerializerOptions<ObjectStyle>;
27
-
}
28
-
>;
29
-
}
24
+
parameters?: Record<string, QuerySerializerOptionsObject>;
25
+
};
30
26
31
27
const serializeFormDataPair = (
32
28
data: FormData,
+7
-13
examples/openapi-ts-tanstack-angular-query-experimental/src/client/client/utils.gen.ts
+7
-13
examples/openapi-ts-tanstack-angular-query-experimental/src/client/client/utils.gen.ts
···
101
101
};
102
102
103
103
export const createQuerySerializer = <T = unknown>({
104
-
allowReserved,
105
-
array,
106
-
object,
107
104
parameters = {},
105
+
...args
108
106
}: QuerySerializerOptions = {}) => {
109
107
const querySerializer = (queryParams: T) => {
110
108
const search: string[] = [];
···
116
114
continue;
117
115
}
118
116
119
-
// Get parameter-specific settings or fall back to global
120
-
const paramConfig = parameters[name] || {};
121
-
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
117
+
const options = parameters[name] || args;
122
118
123
119
if (Array.isArray(value)) {
124
120
const serializedArray = serializeArrayParam({
125
-
allowReserved: paramAllowReserved,
121
+
allowReserved: options.allowReserved,
126
122
explode: true,
127
123
name,
128
124
style: 'form',
129
125
value,
130
-
...array,
131
-
...paramConfig.array,
126
+
...options.array,
132
127
});
133
128
if (serializedArray) search.push(serializedArray);
134
129
} else if (typeof value === 'object') {
135
130
const serializedObject = serializeObjectParam({
136
-
allowReserved: paramAllowReserved,
131
+
allowReserved: options.allowReserved,
137
132
explode: true,
138
133
name,
139
134
style: 'deepObject',
140
135
value: value as Record<string, unknown>,
141
-
...object,
142
-
...paramConfig.object,
136
+
...options.object,
143
137
});
144
138
if (serializedObject) search.push(serializedObject);
145
139
} else {
146
140
const serializedPrimitive = serializePrimitiveParam({
147
-
allowReserved: paramAllowReserved,
141
+
allowReserved: options.allowReserved,
148
142
name,
149
143
value: value as string,
150
144
});
+8
-12
examples/openapi-ts-tanstack-angular-query-experimental/src/client/core/bodySerializer.gen.ts
+8
-12
examples/openapi-ts-tanstack-angular-query-experimental/src/client/core/bodySerializer.gen.ts
···
10
10
11
11
export type BodySerializer = (body: any) => any;
12
12
13
-
export interface QuerySerializerOptions {
13
+
type QuerySerializerOptionsObject = {
14
14
allowReserved?: boolean;
15
-
array?: SerializerOptions<ArrayStyle>;
16
-
object?: SerializerOptions<ObjectStyle>;
15
+
array?: Partial<SerializerOptions<ArrayStyle>>;
16
+
object?: Partial<SerializerOptions<ObjectStyle>>;
17
+
};
18
+
19
+
export type QuerySerializerOptions = QuerySerializerOptionsObject & {
17
20
/**
18
21
* Per-parameter serialization overrides. When provided, these settings
19
22
* override the global array/object settings for specific parameter names.
20
23
*/
21
-
parameters?: Record<
22
-
string,
23
-
{
24
-
allowReserved?: boolean;
25
-
array?: SerializerOptions<ArrayStyle>;
26
-
object?: SerializerOptions<ObjectStyle>;
27
-
}
28
-
>;
29
-
}
24
+
parameters?: Record<string, QuerySerializerOptionsObject>;
25
+
};
30
26
31
27
const serializeFormDataPair = (
32
28
data: FormData,
+7
-13
examples/openapi-ts-tanstack-react-query/src/client/client/utils.gen.ts
+7
-13
examples/openapi-ts-tanstack-react-query/src/client/client/utils.gen.ts
···
17
17
} from './types.gen';
18
18
19
19
export const createQuerySerializer = <T = unknown>({
20
-
allowReserved,
21
-
array,
22
-
object,
23
20
parameters = {},
21
+
...args
24
22
}: QuerySerializerOptions = {}) => {
25
23
const querySerializer = (queryParams: T) => {
26
24
const search: string[] = [];
···
32
30
continue;
33
31
}
34
32
35
-
// Get parameter-specific settings or fall back to global
36
-
const paramConfig = parameters[name] || {};
37
-
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
const options = parameters[name] || args;
38
34
39
35
if (Array.isArray(value)) {
40
36
const serializedArray = serializeArrayParam({
41
-
allowReserved: paramAllowReserved,
37
+
allowReserved: options.allowReserved,
42
38
explode: true,
43
39
name,
44
40
style: 'form',
45
41
value,
46
-
...array,
47
-
...paramConfig.array,
42
+
...options.array,
48
43
});
49
44
if (serializedArray) search.push(serializedArray);
50
45
} else if (typeof value === 'object') {
51
46
const serializedObject = serializeObjectParam({
52
-
allowReserved: paramAllowReserved,
47
+
allowReserved: options.allowReserved,
53
48
explode: true,
54
49
name,
55
50
style: 'deepObject',
56
51
value: value as Record<string, unknown>,
57
-
...object,
58
-
...paramConfig.object,
52
+
...options.object,
59
53
});
60
54
if (serializedObject) search.push(serializedObject);
61
55
} else {
62
56
const serializedPrimitive = serializePrimitiveParam({
63
-
allowReserved: paramAllowReserved,
57
+
allowReserved: options.allowReserved,
64
58
name,
65
59
value: value as string,
66
60
});
+8
-12
examples/openapi-ts-tanstack-react-query/src/client/core/bodySerializer.gen.ts
+8
-12
examples/openapi-ts-tanstack-react-query/src/client/core/bodySerializer.gen.ts
···
10
10
11
11
export type BodySerializer = (body: any) => any;
12
12
13
-
export interface QuerySerializerOptions {
13
+
type QuerySerializerOptionsObject = {
14
14
allowReserved?: boolean;
15
-
array?: SerializerOptions<ArrayStyle>;
16
-
object?: SerializerOptions<ObjectStyle>;
15
+
array?: Partial<SerializerOptions<ArrayStyle>>;
16
+
object?: Partial<SerializerOptions<ObjectStyle>>;
17
+
};
18
+
19
+
export type QuerySerializerOptions = QuerySerializerOptionsObject & {
17
20
/**
18
21
* Per-parameter serialization overrides. When provided, these settings
19
22
* override the global array/object settings for specific parameter names.
20
23
*/
21
-
parameters?: Record<
22
-
string,
23
-
{
24
-
allowReserved?: boolean;
25
-
array?: SerializerOptions<ArrayStyle>;
26
-
object?: SerializerOptions<ObjectStyle>;
27
-
}
28
-
>;
29
-
}
24
+
parameters?: Record<string, QuerySerializerOptionsObject>;
25
+
};
30
26
31
27
const serializeFormDataPair = (
32
28
data: FormData,
+7
-13
examples/openapi-ts-tanstack-svelte-query/src/client/client/utils.gen.ts
+7
-13
examples/openapi-ts-tanstack-svelte-query/src/client/client/utils.gen.ts
···
17
17
} from './types.gen';
18
18
19
19
export const createQuerySerializer = <T = unknown>({
20
-
allowReserved,
21
-
array,
22
-
object,
23
20
parameters = {},
21
+
...args
24
22
}: QuerySerializerOptions = {}) => {
25
23
const querySerializer = (queryParams: T) => {
26
24
const search: string[] = [];
···
32
30
continue;
33
31
}
34
32
35
-
// Get parameter-specific settings or fall back to global
36
-
const paramConfig = parameters[name] || {};
37
-
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved;
33
+
const options = parameters[name] || args;
38
34
39
35
if (Array.isArray(value)) {
40
36
const serializedArray = serializeArrayParam({
41
-
allowReserved: paramAllowReserved,
37
+
allowReserved: options.allowReserved,
42
38
explode: true,
43
39
name,
44
40
style: 'form',
45
41
value,
46
-
...array,
47
-
...paramConfig.array,
42
+
...options.array,
48
43
});
49
44
if (serializedArray) search.push(serializedArray);
50
45
} else if (typeof value === 'object') {
51
46
const serializedObject = serializeObjectParam({
52
-
allowReserved: paramAllowReserved,
47
+
allowReserved: options.allowReserved,
53
48
explode: true,
54
49
name,
55
50
style: 'deepObject',
56
51
value: value as Record<string, unknown>,
57
-
...object,
58
-
...paramConfig.object,
52
+
...options.object,
59
53
});
60
54
if (serializedObject) search.push(serializedObject);
61
55
} else {
62
56
const serializedPrimitive = serializePrimitiveParam({
63
-
allowReserved: paramAllowReserved,
57
+
allowReserved: options.allowReserved,
64
58
name,
65
59
value: value as string,
66
60
});
+8
-12
examples/openapi-ts-tanstack-svelte-query/src/client/core/bodySerializer.gen.ts
+8
-12
examples/openapi-ts-tanstack-svelte-query/src/client/core/bodySerializer.gen.ts
···
10
10
11
11
export type BodySerializer = (body: any) => any;
12
12
13
-
export interface QuerySerializerOptions {
13
+
type QuerySerializerOptionsObject = {
14
14
allowReserved?: boolean;
15
-
array?: SerializerOptions<ArrayStyle>;
16
-
object?: SerializerOptions<ObjectStyle>;
15
+
array?: Partial<SerializerOptions<ArrayStyle>>;
16
+
object?: Partial<SerializerOptions<ObjectStyle>>;
17
+
};
18
+
19
+
export type QuerySerializerOptions = QuerySerializerOptionsObject & {
17
20
/**
18
21
* Per-parameter serialization overrides. When provided, these settings
19
22
* override the global array/object settings for specific parameter names.
20
23
*/
21
-
parameters?: Record<
22
-
string,
23
-
{
24
-
allowReserved?: boolean;
25
-
array?: SerializerOptions<ArrayStyle>;
26
-
object?: SerializerOptions<ObjectStyle>;
27
-
}
28
-
>;
29
-
}
24
+
parameters?: Record<string, QuerySerializerOptionsObject>;
25
+
};
30
26
31
27
const serializeFormDataPair = (
32
28
data: FormData,
+8
-14
examples/openapi-ts-tanstack-vue-query/src/client/client/utils.gen.ts
+8
-14
examples/openapi-ts-tanstack-vue-query/src/client/client/utils.gen.ts
···
12
12
import type { Client, ClientOptions, Config, RequestOptions } from './types.gen'
13
13
14
14
export const createQuerySerializer = <T = unknown>({
15
-
allowReserved,
16
-
array,
17
-
object,
18
-
parameters = {}
15
+
parameters = {},
16
+
...args
19
17
}: QuerySerializerOptions = {}) => {
20
18
const querySerializer = (queryParams: T) => {
21
19
const search: string[] = []
···
27
25
continue
28
26
}
29
27
30
-
// Get parameter-specific settings or fall back to global
31
-
const paramConfig = parameters[name] || {}
32
-
const paramAllowReserved = paramConfig.allowReserved ?? allowReserved
28
+
const options = parameters[name] || args
33
29
34
30
if (Array.isArray(value)) {
35
31
const serializedArray = serializeArrayParam({
36
-
allowReserved: paramAllowReserved,
32
+
allowReserved: options.allowReserved,
37
33
explode: true,
38
34
name,
39
35
style: 'form',
40
36
value,
41
-
...array,
42
-
...paramConfig.array
37
+
...options.array
43
38
})
44
39
if (serializedArray) search.push(serializedArray)
45
40
} else if (typeof value === 'object') {
46
41
const serializedObject = serializeObjectParam({
47
-
allowReserved: paramAllowReserved,
42
+
allowReserved: options.allowReserved,
48
43
explode: true,
49
44
name,
50
45
style: 'deepObject',
51
46
value: value as Record<string, unknown>,
52
-
...object,
53
-
...paramConfig.object
47
+
...options.object
54
48
})
55
49
if (serializedObject) search.push(serializedObject)
56
50
} else {
57
51
const serializedPrimitive = serializePrimitiveParam({
58
-
allowReserved: paramAllowReserved,
52
+
allowReserved: options.allowReserved,
59
53
name,
60
54
value: value as string
61
55
})
+7
-11
examples/openapi-ts-tanstack-vue-query/src/client/core/bodySerializer.gen.ts
+7
-11
examples/openapi-ts-tanstack-vue-query/src/client/core/bodySerializer.gen.ts
···
6
6
7
7
export type BodySerializer = (body: any) => any
8
8
9
-
export interface QuerySerializerOptions {
9
+
type QuerySerializerOptionsObject = {
10
10
allowReserved?: boolean
11
-
array?: SerializerOptions<ArrayStyle>
12
-
object?: SerializerOptions<ObjectStyle>
11
+
array?: Partial<SerializerOptions<ArrayStyle>>
12
+
object?: Partial<SerializerOptions<ObjectStyle>>
13
+
}
14
+
15
+
export type QuerySerializerOptions = QuerySerializerOptionsObject & {
13
16
/**
14
17
* Per-parameter serialization overrides. When provided, these settings
15
18
* override the global array/object settings for specific parameter names.
16
19
*/
17
-
parameters?: Record<
18
-
string,
19
-
{
20
-
allowReserved?: boolean
21
-
array?: SerializerOptions<ArrayStyle>
22
-
object?: SerializerOptions<ObjectStyle>
23
-
}
24
-
>
20
+
parameters?: Record<string, QuerySerializerOptionsObject>
25
21
}
26
22
27
23
const serializeFormDataPair = (data: FormData, key: string, value: unknown): void => {