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