mokkenstorm.dev
fork of hey-api/openapi-ts because I need some additional things
test: reduce the amount of diff lines
+3857
-3655
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/body-response-text-plain/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/body-response-text-plain/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/form-data/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/form-data/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@angular/common/default-class/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@angular/common/default-class/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@angular/common/default/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@angular/common/default/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/client-fetch/sdk-nested-classes-instance/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/client-fetch/sdk-nested-classes-instance/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/client-fetch/sdk-nested-classes/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/client-fetch/sdk-nested-classes/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/sdk/default/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/sdk/default/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/sdk/instance/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/sdk/instance/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/sdk/throwOnError/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/sdk/throwOnError/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/transformers/type-format-valibot/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/transformers/type-format-valibot/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/transformers/type-format-zod/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/transformers/type-format-zod/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/typescript/transforms-read-write-custom-name/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/typescript/transforms-read-write-custom-name/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/typescript/transforms-read-write-ignore/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@hey-api/typescript/transforms-read-write-ignore/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@pinia/colada/asClass/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@pinia/colada/asClass/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@pinia/colada/fetch/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@pinia/colada/fetch/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/asClass/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/asClass/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/axios/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/axios/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/fetch/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/fetch/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/name-builder/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/angular-query-experimental/name-builder/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/asClass/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/asClass/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/axios/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/axios/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/fetch/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/fetch/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/name-builder/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/react-query/name-builder/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/asClass/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/asClass/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/axios/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/axios/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/fetch/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/fetch/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/name-builder/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/solid-query/name-builder/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/asClass/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/asClass/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/axios/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/axios/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/fetch/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/fetch/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/name-builder/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/svelte-query/name-builder/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/asClass/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/asClass/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/axios/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/axios/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/fetch/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/fetch/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/name-builder/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@tanstack/vue-query/name-builder/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/schema-unknown/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/schema-unknown/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/security-api-key/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/security-api-key/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/security-basic/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/security-basic/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/security-false/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/security-false/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/security-oauth2/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/security-oauth2/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/servers-base-path/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/servers-base-path/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/servers-host/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/servers-host/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/servers/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/servers/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/transforms-read-write/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/transforms-read-write/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/body-response-text-plain/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/body-response-text-plain/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/content-types/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/content-types/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/internal-name-conflict/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/internal-name-conflict/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/parameter-explode-false-axios/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/parameter-explode-false-axios/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/parameter-explode-false/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/parameter-explode-false/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@angular/common/default-class/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@angular/common/default-class/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@angular/common/default/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@angular/common/default/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/client-fetch/sdk-nested-classes-instance/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/client-fetch/sdk-nested-classes-instance/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/client-fetch/sdk-nested-classes/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/client-fetch/sdk-nested-classes/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/sdk/default/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/sdk/default/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/sdk/instance/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/sdk/instance/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/sdk/throwOnError/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/sdk/throwOnError/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/transformers/type-format-valibot/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/transformers/type-format-valibot/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/transformers/type-format-zod/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/transformers/type-format-zod/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/typescript/transforms-read-write-custom-name/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/typescript/transforms-read-write-custom-name/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/typescript/transforms-read-write-ignore/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@hey-api/typescript/transforms-read-write-ignore/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@pinia/colada/asClass/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@pinia/colada/asClass/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@pinia/colada/fetch/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@pinia/colada/fetch/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/asClass/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/asClass/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/axios/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/axios/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/fetch/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/fetch/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/name-builder/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/angular-query-experimental/name-builder/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/asClass/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/asClass/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/axios/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/axios/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/fetch/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/fetch/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/name-builder/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/react-query/name-builder/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/asClass/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/asClass/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/axios/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/axios/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/fetch/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/fetch/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/name-builder/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/solid-query/name-builder/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/asClass/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/asClass/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/axios/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/axios/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/fetch/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/fetch/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/name-builder/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/svelte-query/name-builder/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/asClass/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/asClass/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/axios/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/axios/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/fetch/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/fetch/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/name-builder/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@tanstack/vue-query/name-builder/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-api-key/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-api-key/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-false/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-false/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-http-bearer/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-http-bearer/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-oauth2/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-oauth2/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-open-id-connect/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/security-open-id-connect/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/servers/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/servers/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/transformers-all-of/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/transformers-all-of/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/transformers-any-of-null/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/transformers-any-of-null/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/transformers-array/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/transformers-array/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/transformers-recursive/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/transformers-recursive/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/transforms-read-write/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/transforms-read-write/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/body-response-text-plain/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/body-response-text-plain/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-axios/base-url-false/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-axios/base-url-false/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-axios/base-url-number/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-axios/base-url-number/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-axios/base-url-strict/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-axios/base-url-strict/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-axios/base-url-string/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-axios/base-url-string/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-axios/clean-false/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-axios/clean-false/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-axios/default/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-axios/default/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-axios/import-file-extension-ts/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-axios/import-file-extension-ts/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-axios/sdk-client-optional/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-axios/sdk-client-optional/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-axios/sdk-client-required/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-axios/sdk-client-required/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-axios/tsconfig-nodenext-sdk/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-axios/tsconfig-nodenext-sdk/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-fetch/base-url-false/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-fetch/base-url-false/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-fetch/base-url-number/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-fetch/base-url-number/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-fetch/base-url-strict/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-fetch/base-url-strict/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-fetch/base-url-string/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-fetch/base-url-string/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-fetch/clean-false/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-fetch/clean-false/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-fetch/default/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-fetch/default/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-fetch/import-file-extension-ts/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-fetch/import-file-extension-ts/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-fetch/sdk-client-optional/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-fetch/sdk-client-optional/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-fetch/sdk-client-required/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-fetch/sdk-client-required/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-fetch/tsconfig-nodenext-sdk/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-fetch/tsconfig-nodenext-sdk/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-next/base-url-false/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-next/base-url-false/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-next/base-url-number/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-next/base-url-number/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-next/base-url-strict/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-next/base-url-strict/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-next/base-url-string/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-next/base-url-string/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-next/clean-false/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-next/clean-false/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-next/default/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-next/default/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-next/import-file-extension-ts/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-next/import-file-extension-ts/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-next/sdk-client-optional/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-next/sdk-client-optional/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-next/sdk-client-required/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-next/sdk-client-required/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-next/tsconfig-nodenext-sdk/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-next/tsconfig-nodenext-sdk/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-nuxt/base-url-false/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-nuxt/base-url-false/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-nuxt/base-url-number/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-nuxt/base-url-number/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-nuxt/base-url-strict/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-nuxt/base-url-strict/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-nuxt/base-url-string/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-nuxt/base-url-string/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-nuxt/clean-false/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-nuxt/clean-false/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-nuxt/default/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-nuxt/default/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-nuxt/import-file-extension-ts/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-nuxt/import-file-extension-ts/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-nuxt/sdk-client-optional/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-nuxt/sdk-client-optional/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-nuxt/sdk-client-required/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-nuxt/sdk-client-required/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-nuxt/tsconfig-nodenext-sdk/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-nuxt/tsconfig-nodenext-sdk/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-ofetch/base-url-false/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-ofetch/base-url-false/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-ofetch/base-url-number/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-ofetch/base-url-number/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-ofetch/base-url-strict/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-ofetch/base-url-strict/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-ofetch/base-url-string/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-ofetch/base-url-string/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-ofetch/clean-false/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-ofetch/clean-false/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-ofetch/default/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-ofetch/default/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-ofetch/import-file-extension-ts/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-ofetch/import-file-extension-ts/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-ofetch/sdk-client-optional/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-ofetch/sdk-client-optional/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-ofetch/sdk-client-required/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-ofetch/sdk-client-required/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-ofetch/tsconfig-nodenext-sdk/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/clients/@hey-api/client-ofetch/tsconfig-nodenext-sdk/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/content-types/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/content-types/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/headers/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/headers/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/internal-name-conflict/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/internal-name-conflict/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/pagination-ref/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/pagination-ref/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/parameter-explode-false-axios/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/parameter-explode-false-axios/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/parameter-explode-false/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/parameter-explode-false/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@angular/common/default-class/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@angular/common/default-class/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@angular/common/default/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@angular/common/default/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/client-fetch/sdk-nested-classes-instance/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/client-fetch/sdk-nested-classes-instance/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/client-fetch/sdk-nested-classes/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/client-fetch/sdk-nested-classes/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/sdk/default/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/sdk/default/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/sdk/instance/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/sdk/instance/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/sdk/throwOnError/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/sdk/throwOnError/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/transformers/type-format-valibot/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/transformers/type-format-valibot/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/transformers/type-format-zod/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/transformers/type-format-zod/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/typescript/transforms-read-write-custom-name/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/typescript/transforms-read-write-custom-name/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/typescript/transforms-read-write-ignore/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@hey-api/typescript/transforms-read-write-ignore/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@pinia/colada/asClass/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@pinia/colada/asClass/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@pinia/colada/fetch/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@pinia/colada/fetch/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/asClass/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/asClass/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/axios/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/axios/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/fetch/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/fetch/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/name-builder/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/angular-query-experimental/name-builder/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/asClass/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/asClass/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/axios/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/axios/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/fetch/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/fetch/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/name-builder/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/react-query/name-builder/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/asClass/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/asClass/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/axios/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/axios/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/fetch/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/fetch/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/name-builder/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/solid-query/name-builder/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/asClass/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/asClass/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/axios/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/axios/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/fetch/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/fetch/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/name-builder/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/svelte-query/name-builder/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/asClass/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/asClass/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/axios/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/axios/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/fetch/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/fetch/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/name-builder/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@tanstack/vue-query/name-builder/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-api-key/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-api-key/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-false/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-false/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-http-bearer/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-http-bearer/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-oauth2/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-oauth2/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-open-id-connect/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/security-open-id-connect/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/servers/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/servers/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-angular/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-angular/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-axios/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-axios/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-fetch/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-fetch/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-next/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-next/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-nuxt/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-nuxt/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-ofetch/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/sse-ofetch/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/transformers-all-of/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/transformers-all-of/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/transformers-any-of-null/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/transformers-any-of-null/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/transformers-array/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/transformers-array/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/transformers-recursive/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/transformers-recursive/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/transforms-read-write/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/transforms-read-write/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/plugins/@tanstack/meta/core/params.gen.ts
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/plugins/@tanstack/meta/core/params.gen.ts
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/test/generated/v3_no_index/core/params.gen.ts.snap
+19
-18
packages/openapi-ts-tests/main/test/__snapshots__/test/generated/v3_no_index/core/params.gen.ts.snap
···
2
2
3
3
type Slot = 'body' | 'headers' | 'path' | 'query';
4
4
5
-
type Params = {
6
-
body: unknown;
7
-
headers: Record<string, unknown>;
8
-
path: Record<string, unknown>;
9
-
query: Record<string, unknown>;
10
-
}
11
-
12
-
type KeyMap = Map<
13
-
string,
14
-
{
15
-
in: Slot;
16
-
map?: string;
17
-
} | {
18
-
in?: never;
19
-
map: Slot;
20
-
}
21
-
>;
22
-
23
5
export type Field =
24
6
| {
25
7
in: Exclude<Slot, 'body'>;
···
68
50
};
69
51
const extraPrefixes = Object.entries(extraPrefixesMap);
70
52
53
+
type KeyMap = Map<
54
+
string,
55
+
| {
56
+
in: Slot;
57
+
map?: string;
58
+
}
59
+
| {
60
+
in?: never;
61
+
map: Slot;
62
+
}
63
+
>;
64
+
71
65
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
72
66
if (!map) {
73
67
map = new Map();
···
91
85
}
92
86
93
87
return map;
88
+
};
89
+
90
+
interface Params {
91
+
body: unknown;
92
+
headers: Record<string, unknown>;
93
+
path: Record<string, unknown>;
94
+
query: Record<string, unknown>;
94
95
};
95
96
96
97
const stripEmptySlots = (params: Params) => {
+19
-19
packages/openapi-ts/src/plugins/@hey-api/client-core/bundle/params.ts
+19
-19
packages/openapi-ts/src/plugins/@hey-api/client-core/bundle/params.ts
···
1
1
type Slot = 'body' | 'headers' | 'path' | 'query';
2
2
3
-
type Params = {
4
-
body: unknown;
5
-
headers: Record<string, unknown>;
6
-
path: Record<string, unknown>;
7
-
query: Record<string, unknown>;
8
-
};
9
-
10
-
type KeyMap = Map<
11
-
string,
12
-
| {
13
-
in: Slot;
14
-
map?: string;
15
-
}
16
-
| {
17
-
in?: never;
18
-
map: Slot;
19
-
}
20
-
>;
21
-
22
3
export type Field =
23
4
| {
24
5
in: Exclude<Slot, 'body'>;
···
67
48
};
68
49
const extraPrefixes = Object.entries(extraPrefixesMap);
69
50
51
+
type KeyMap = Map<
52
+
string,
53
+
| {
54
+
in: Slot;
55
+
map?: string;
56
+
}
57
+
| {
58
+
in?: never;
59
+
map: Slot;
60
+
}
61
+
>;
62
+
70
63
const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
71
64
if (!map) {
72
65
map = new Map();
···
91
84
92
85
return map;
93
86
};
87
+
88
+
interface Params {
89
+
body: unknown;
90
+
headers: Record<string, unknown>;
91
+
path: Record<string, unknown>;
92
+
query: Record<string, unknown>;
93
+
}
94
94
95
95
const stripEmptySlots = (params: Params) => {
96
96
for (const [slot, value] of Object.entries(params)) {