diff --git a/dev/openapi-ts.config.ts b/dev/openapi-ts.config.ts
index 893084527..2320c3687 100644
--- a/dev/openapi-ts.config.ts
+++ b/dev/openapi-ts.config.ts
@@ -33,32 +33,32 @@ export default defineConfig(() => {
           //   openapi: '3.1.0',
           //   paths: {},
           // },
-          // path: path.resolve(
-          //   getSpecsPath(),
-          //   // '3.0.x',
-          //   '3.1.x',
-          //   // 'circular.yaml',
-          //   // 'dutchie.json',
-          //   // 'invalid',
-          //   'full.yaml',
-          //   // 'object-property-names.yaml',
-          //   // 'openai.yaml',
-          //   // 'opencode.yaml',
-          //   // 'pagination-ref.yaml',
-          //   // 'sdk-instance.yaml',
-          //   // 'string-with-format.yaml',
-          //   // 'transformers.json',
-          //   // 'type-format.yaml',
-          //   // 'validators.yaml',
-          //   // 'validators-circular-ref.json',
-          //   // 'validators-circular-ref-2.yaml',
-          //   // 'zoom-video-sdk.json',
-          // ),
+          path: path.resolve(
+            getSpecsPath(),
+            // '3.0.x',
+            '3.1.x',
+            // 'circular.yaml',
+            // 'dutchie.json',
+            // 'invalid',
+            'full.yaml',
+            // 'object-property-names.yaml',
+            // 'openai.yaml',
+            // 'opencode.yaml',
+            // 'pagination-ref.yaml',
+            // 'sdk-instance.yaml',
+            // 'string-with-format.yaml',
+            // 'transformers.json',
+            // 'type-format.yaml',
+            // 'validators.yaml',
+            // 'validators-circular-ref.json',
+            // 'validators-circular-ref-2.yaml',
+            // 'zoom-video-sdk.json',
+          ),
           // path: 'https://get.heyapi.dev/hey-api/backend?branch=main&version=1.0.0',
           // path: 'http://localhost:4000/',
           // path: 'http://localhost:8000/openapi.json',
           // path: 'https://mongodb-mms-prod-build-server.s3.amazonaws.com/openapi/2caffd88277a4e27c95dcefc7e3b6a63a3b03297-v2-2023-11-15.json',
-          path: 'https://raw.githubusercontent.com/swagger-api/swagger-petstore/master/src/main/resources/openapi.yaml',
+          // path: 'https://raw.githubusercontent.com/swagger-api/swagger-petstore/master/src/main/resources/openapi.yaml',
           // watch: {
           //   enabled: true,
           //   interval: 500,
@@ -296,7 +296,7 @@ export default defineConfig(() => {
           name: '@hey-api/transformers',
         },
         {
-          // name: 'fastify',
+          name: 'fastify',
         },
         {
           name: 'swr',
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@pinia/colada/asClass/@pinia/colada.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@pinia/colada/asClass/@pinia/colada.gen.ts
index 1d845eca9..10ae99233 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@pinia/colada/asClass/@pinia/colada.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@pinia/colada/asClass/@pinia/colada.gen.ts
@@ -39,12 +39,10 @@ const createQueryKey = <TOptions extends Options>(id: string, options?: TOptions
             params.query = normalizedQuery;
         }
     }
-    return [
-        params
-    ];
+    return [params];
 };
 
-export const getFooQueryKey = (options?: Options<GetFooData>) => createQueryKey('getFoo', options);
+export const getFooQueryKey = (options?: Options<GetFooData>) => createQueryKey("getFoo", options);
 
 export const getFooQuery = defineQueryOptions((options?: Options<GetFooData>) => ({
     key: getFooQueryKey(options),
@@ -58,33 +56,29 @@ export const getFooQuery = defineQueryOptions((options?: Options<GetFooData>) =>
     }
 }));
 
-export const fooPostMutation = (options?: Partial<Options<FooPostData>>): UseMutationOptions<FooPostResponse, Options<FooPostData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await FooBazService.fooService.post({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const fooPostMutation = (options?: Partial<Options<FooPostData>>): UseMutationOptions<FooPostResponse, Options<FooPostData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await FooBazService.fooService.post({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const fooPutMutation = (options?: Partial<Options<FooPutData>>): UseMutationOptions<FooPutResponse, Options<FooPutData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await FooBazService.fooService.put({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const fooPutMutation = (options?: Partial<Options<FooPutData>>): UseMutationOptions<FooPutResponse, Options<FooPutData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await FooBazService.fooService.put({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const getFooBarQueryKey = (options?: Options<GetFooBarData>) => createQueryKey('getFooBar', options);
+export const getFooBarQueryKey = (options?: Options<GetFooBarData>) => createQueryKey("getFooBar", options);
 
 export const getFooBarQuery = defineQueryOptions((options?: Options<GetFooBarData>) => ({
     key: getFooBarQueryKey(options),
@@ -98,28 +92,24 @@ export const getFooBarQuery = defineQueryOptions((options?: Options<GetFooBarDat
     }
 }));
 
-export const fooBarPostMutation = (options?: Partial<Options<FooBarPostData>>): UseMutationOptions<FooBarPostResponse, Options<FooBarPostData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await FooBazService.fooService.barService.post({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const fooBarPostMutation = (options?: Partial<Options<FooBarPostData>>): UseMutationOptions<FooBarPostResponse, Options<FooBarPostData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await FooBazService.fooService.barService.post({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const fooBarPutMutation = (options?: Partial<Options<FooBarPutData>>): UseMutationOptions<FooBarPutResponse, Options<FooBarPutData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await FooBazService.fooService.barService.put({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const fooBarPutMutation = (options?: Partial<Options<FooBarPutData>>): UseMutationOptions<FooBarPutResponse, Options<FooBarPutData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await FooBazService.fooService.barService.put({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@pinia/colada/fetch/@pinia/colada.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@pinia/colada/fetch/@pinia/colada.gen.ts
index f5f6c7765..8feb7bb8a 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@pinia/colada/fetch/@pinia/colada.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/@pinia/colada/fetch/@pinia/colada.gen.ts
@@ -39,12 +39,10 @@ const createQueryKey = <TOptions extends Options>(id: string, options?: TOptions
             params.query = normalizedQuery;
         }
     }
-    return [
-        params
-    ];
+    return [params];
 };
 
-export const serviceWithEmptyTagQueryKey = (options?: Options<ServiceWithEmptyTagData>) => createQueryKey('serviceWithEmptyTag', options);
+export const serviceWithEmptyTagQueryKey = (options?: Options<ServiceWithEmptyTagData>) => createQueryKey("serviceWithEmptyTag", options);
 
 export const serviceWithEmptyTagQuery = defineQueryOptions((options?: Options<ServiceWithEmptyTagData>) => ({
     key: serviceWithEmptyTagQueryKey(options),
@@ -58,46 +56,40 @@ export const serviceWithEmptyTagQuery = defineQueryOptions((options?: Options<Se
     }
 }));
 
-export const patchApiVbyApiVersionNoTagMutation = (options?: Partial<Options<PatchApiVbyApiVersionNoTagData>>): UseMutationOptions<unknown, Options<PatchApiVbyApiVersionNoTagData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await patchApiVbyApiVersionNoTag({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const patchApiVbyApiVersionNoTagMutation = (options?: Partial<Options<PatchApiVbyApiVersionNoTagData>>): UseMutationOptions<unknown, Options<PatchApiVbyApiVersionNoTagData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await patchApiVbyApiVersionNoTag({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const fooWowMutation = (options?: Partial<Options<FooWowData>>): UseMutationOptions<unknown, Options<FooWowData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await fooWow({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const fooWowMutation = (options?: Partial<Options<FooWowData>>): UseMutationOptions<unknown, Options<FooWowData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await fooWow({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const deleteCallWithoutParametersAndResponseMutation = (options?: Partial<Options<DeleteCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, Options<DeleteCallWithoutParametersAndResponseData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await deleteCallWithoutParametersAndResponse({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const deleteCallWithoutParametersAndResponseMutation = (options?: Partial<Options<DeleteCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, Options<DeleteCallWithoutParametersAndResponseData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await deleteCallWithoutParametersAndResponse({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const getCallWithoutParametersAndResponseQueryKey = (options?: Options<GetCallWithoutParametersAndResponseData>) => createQueryKey('getCallWithoutParametersAndResponse', options);
+export const getCallWithoutParametersAndResponseQueryKey = (options?: Options<GetCallWithoutParametersAndResponseData>) => createQueryKey("getCallWithoutParametersAndResponse", options);
 
 export const getCallWithoutParametersAndResponseQuery = defineQueryOptions((options?: Options<GetCallWithoutParametersAndResponseData>) => ({
     key: getCallWithoutParametersAndResponseQueryKey(options),
@@ -111,85 +103,73 @@ export const getCallWithoutParametersAndResponseQuery = defineQueryOptions((opti
     }
 }));
 
-export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PatchCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, Options<PatchCallWithoutParametersAndResponseData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await patchCallWithoutParametersAndResponse({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PatchCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, Options<PatchCallWithoutParametersAndResponseData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await patchCallWithoutParametersAndResponse({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, Options<PostCallWithoutParametersAndResponseData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, Options<PostCallWithoutParametersAndResponseData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await postCallWithoutParametersAndResponse({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const putCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PutCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, Options<PutCallWithoutParametersAndResponseData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await putCallWithoutParametersAndResponse({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const putCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PutCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, Options<PutCallWithoutParametersAndResponseData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await putCallWithoutParametersAndResponse({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): UseMutationOptions<unknown, Options<CallWithDescriptionsData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): UseMutationOptions<unknown, Options<CallWithDescriptionsData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await callWithDescriptions({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): UseMutationOptions<unknown, Options<CallWithParametersData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): UseMutationOptions<unknown, Options<CallWithParametersData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await callWithParameters({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): UseMutationOptions<unknown, Options<CallWithWeirdParameterNamesData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): UseMutationOptions<unknown, Options<CallWithWeirdParameterNamesData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await callWithWeirdParameterNames({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const callWithDefaultParametersQueryKey = (options: Options<CallWithDefaultParametersData>) => createQueryKey('callWithDefaultParameters', options);
+export const callWithDefaultParametersQueryKey = (options: Options<CallWithDefaultParametersData>) => createQueryKey("callWithDefaultParameters", options);
 
 export const callWithDefaultParametersQuery = defineQueryOptions((options: Options<CallWithDefaultParametersData>) => ({
     key: callWithDefaultParametersQueryKey(options),
@@ -203,46 +183,40 @@ export const callWithDefaultParametersQuery = defineQueryOptions((options: Optio
     }
 }));
 
-export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): UseMutationOptions<unknown, Options<CallWithDefaultOptionalParametersData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): UseMutationOptions<unknown, Options<CallWithDefaultOptionalParametersData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await callWithDefaultOptionalParameters({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const callToTestOrderOfParamsMutation = (options?: Partial<Options<CallToTestOrderOfParamsData>>): UseMutationOptions<unknown, Options<CallToTestOrderOfParamsData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await callToTestOrderOfParams({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const callToTestOrderOfParamsMutation = (options?: Partial<Options<CallToTestOrderOfParamsData>>): UseMutationOptions<unknown, Options<CallToTestOrderOfParamsData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await callToTestOrderOfParams({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const duplicateNameMutation = (options?: Partial<Options<DuplicateNameData>>): UseMutationOptions<unknown, Options<DuplicateNameData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await duplicateName({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const duplicateNameMutation = (options?: Partial<Options<DuplicateNameData>>): UseMutationOptions<unknown, Options<DuplicateNameData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await duplicateName({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const duplicateName2QueryKey = (options?: Options<DuplicateName2Data>) => createQueryKey('duplicateName2', options);
+export const duplicateName2QueryKey = (options?: Options<DuplicateName2Data>) => createQueryKey("duplicateName2", options);
 
 export const duplicateName2Query = defineQueryOptions((options?: Options<DuplicateName2Data>) => ({
     key: duplicateName2QueryKey(options),
@@ -256,33 +230,29 @@ export const duplicateName2Query = defineQueryOptions((options?: Options<Duplica
     }
 }));
 
-export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): UseMutationOptions<unknown, Options<DuplicateName3Data>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): UseMutationOptions<unknown, Options<DuplicateName3Data>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await duplicateName3({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const duplicateName4Mutation = (options?: Partial<Options<DuplicateName4Data>>): UseMutationOptions<unknown, Options<DuplicateName4Data>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await duplicateName4({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const duplicateName4Mutation = (options?: Partial<Options<DuplicateName4Data>>): UseMutationOptions<unknown, Options<DuplicateName4Data>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await duplicateName4({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const callWithNoContentResponseQueryKey = (options?: Options<CallWithNoContentResponseData>) => createQueryKey('callWithNoContentResponse', options);
+export const callWithNoContentResponseQueryKey = (options?: Options<CallWithNoContentResponseData>) => createQueryKey("callWithNoContentResponse", options);
 
 export const callWithNoContentResponseQuery = defineQueryOptions((options?: Options<CallWithNoContentResponseData>) => ({
     key: callWithNoContentResponseQueryKey(options),
@@ -296,7 +266,7 @@ export const callWithNoContentResponseQuery = defineQueryOptions((options?: Opti
     }
 }));
 
-export const callWithResponseAndNoContentResponseQueryKey = (options?: Options<CallWithResponseAndNoContentResponseData>) => createQueryKey('callWithResponseAndNoContentResponse', options);
+export const callWithResponseAndNoContentResponseQueryKey = (options?: Options<CallWithResponseAndNoContentResponseData>) => createQueryKey("callWithResponseAndNoContentResponse", options);
 
 export const callWithResponseAndNoContentResponseQuery = defineQueryOptions((options?: Options<CallWithResponseAndNoContentResponseData>) => ({
     key: callWithResponseAndNoContentResponseQueryKey(options),
@@ -310,7 +280,7 @@ export const callWithResponseAndNoContentResponseQuery = defineQueryOptions((opt
     }
 }));
 
-export const dummyAQueryKey = (options?: Options<DummyAData>) => createQueryKey('dummyA', options);
+export const dummyAQueryKey = (options?: Options<DummyAData>) => createQueryKey("dummyA", options);
 
 export const dummyAQuery = defineQueryOptions((options?: Options<DummyAData>) => ({
     key: dummyAQueryKey(options),
@@ -324,7 +294,7 @@ export const dummyAQuery = defineQueryOptions((options?: Options<DummyAData>) =>
     }
 }));
 
-export const dummyBQueryKey = (options?: Options<DummyBData>) => createQueryKey('dummyB', options);
+export const dummyBQueryKey = (options?: Options<DummyBData>) => createQueryKey("dummyB", options);
 
 export const dummyBQuery = defineQueryOptions((options?: Options<DummyBData>) => ({
     key: dummyBQueryKey(options),
@@ -338,7 +308,7 @@ export const dummyBQuery = defineQueryOptions((options?: Options<DummyBData>) =>
     }
 }));
 
-export const callWithResponseQueryKey = (options?: Options<CallWithResponseData>) => createQueryKey('callWithResponse', options);
+export const callWithResponseQueryKey = (options?: Options<CallWithResponseData>) => createQueryKey("callWithResponse", options);
 
 export const callWithResponseQuery = defineQueryOptions((options?: Options<CallWithResponseData>) => ({
     key: callWithResponseQueryKey(options),
@@ -352,33 +322,29 @@ export const callWithResponseQuery = defineQueryOptions((options?: Options<CallW
     }
 }));
 
-export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): UseMutationOptions<CallWithDuplicateResponsesResponse, Options<CallWithDuplicateResponsesData>, CallWithDuplicateResponsesError> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): UseMutationOptions<CallWithDuplicateResponsesResponse, Options<CallWithDuplicateResponsesData>, CallWithDuplicateResponsesError> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await callWithDuplicateResponses({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const callWithResponsesMutation = (options?: Partial<Options<CallWithResponsesData>>): UseMutationOptions<CallWithResponsesResponse, Options<CallWithResponsesData>, CallWithResponsesError> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await callWithResponses({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const callWithResponsesMutation = (options?: Partial<Options<CallWithResponsesData>>): UseMutationOptions<CallWithResponsesResponse, Options<CallWithResponsesData>, CallWithResponsesError> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await callWithResponses({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const collectionFormatQueryKey = (options: Options<CollectionFormatData>) => createQueryKey('collectionFormat', options);
+export const collectionFormatQueryKey = (options: Options<CollectionFormatData>) => createQueryKey("collectionFormat", options);
 
 export const collectionFormatQuery = defineQueryOptions((options: Options<CollectionFormatData>) => ({
     key: collectionFormatQueryKey(options),
@@ -392,7 +358,7 @@ export const collectionFormatQuery = defineQueryOptions((options: Options<Collec
     }
 }));
 
-export const typesQueryKey = (options: Options<TypesData>) => createQueryKey('types', options);
+export const typesQueryKey = (options: Options<TypesData>) => createQueryKey("types", options);
 
 export const typesQuery = defineQueryOptions((options: Options<TypesData>) => ({
     key: typesQueryKey(options),
@@ -406,7 +372,7 @@ export const typesQuery = defineQueryOptions((options: Options<TypesData>) => ({
     }
 }));
 
-export const complexTypesQueryKey = (options: Options<ComplexTypesData>) => createQueryKey('complexTypes', options);
+export const complexTypesQueryKey = (options: Options<ComplexTypesData>) => createQueryKey("complexTypes", options);
 
 export const complexTypesQuery = defineQueryOptions((options: Options<ComplexTypesData>) => ({
     key: complexTypesQueryKey(options),
@@ -420,59 +386,51 @@ export const complexTypesQuery = defineQueryOptions((options: Options<ComplexTyp
     }
 }));
 
-export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): UseMutationOptions<unknown, Options<CallWithResultFromHeaderData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): UseMutationOptions<unknown, Options<CallWithResultFromHeaderData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await callWithResultFromHeader({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): UseMutationOptions<unknown, Options<TestErrorCodeData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): UseMutationOptions<unknown, Options<TestErrorCodeData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await testErrorCode({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
 /**
  * Body should not be unknown
  *
  * Body should not be unknown
  */
-export const postApiVbyApiVersionBodyMutation = (options?: Partial<Options<PostApiVbyApiVersionBodyData>>): UseMutationOptions<PostApiVbyApiVersionBodyResponse, Options<PostApiVbyApiVersionBodyData>, PostApiVbyApiVersionBodyError> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await postApiVbyApiVersionBody({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const postApiVbyApiVersionBodyMutation = (options?: Partial<Options<PostApiVbyApiVersionBodyData>>): UseMutationOptions<PostApiVbyApiVersionBodyResponse, Options<PostApiVbyApiVersionBodyData>, PostApiVbyApiVersionBodyError> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await postApiVbyApiVersionBody({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/fastify/default/fastify.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/fastify/default/fastify.gen.ts
index 4b8d75f8e..fdc60433a 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/fastify/default/fastify.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/2.0.x/plugins/fastify/default/fastify.gen.ts
@@ -6,27 +6,27 @@ import type { CallToTestOrderOfParamsData, CallWithDefaultOptionalParametersData
 
 export type RouteHandlers = {
     callWithDescriptions: RouteHandler<{
-        Querystring?: CallWithDescriptionsData['query'];
+        Querystring?: CallWithDescriptionsData["query"];
     }>;
     callWithParameters: RouteHandler<{
-        Headers: CallWithParametersData['headers'];
-        Params: CallWithParametersData['path'];
-        Querystring: CallWithParametersData['query'];
+        Headers: CallWithParametersData["headers"];
+        Params: CallWithParametersData["path"];
+        Querystring: CallWithParametersData["query"];
     }>;
     callWithWeirdParameterNames: RouteHandler<{
-        Body: CallWithWeirdParameterNamesData['body'];
-        Headers: CallWithWeirdParameterNamesData['headers'];
-        Params: CallWithWeirdParameterNamesData['path'];
-        Querystring: CallWithWeirdParameterNamesData['query'];
+        Body: CallWithWeirdParameterNamesData["body"];
+        Headers: CallWithWeirdParameterNamesData["headers"];
+        Params: CallWithWeirdParameterNamesData["path"];
+        Querystring: CallWithWeirdParameterNamesData["query"];
     }>;
     callWithDefaultParameters: RouteHandler<{
-        Querystring: CallWithDefaultParametersData['query'];
+        Querystring: CallWithDefaultParametersData["query"];
     }>;
     callWithDefaultOptionalParameters: RouteHandler<{
-        Querystring?: CallWithDefaultOptionalParametersData['query'];
+        Querystring?: CallWithDefaultOptionalParametersData["query"];
     }>;
     callToTestOrderOfParams: RouteHandler<{
-        Querystring: CallToTestOrderOfParamsData['query'];
+        Querystring: CallToTestOrderOfParamsData["query"];
     }>;
     callWithNoContentResponse: RouteHandler<{
         Reply: CallWithNoContentResponseResponses;
@@ -47,30 +47,30 @@ export type RouteHandlers = {
         Reply: Omit<CallWithResponsesErrors, "default"> & CallWithResponsesResponses;
     }>;
     collectionFormat: RouteHandler<{
-        Querystring: CollectionFormatData['query'];
+        Querystring: CollectionFormatData["query"];
     }>;
     types: RouteHandler<{
-        Params?: TypesData['path'];
-        Querystring: TypesData['query'];
+        Params?: TypesData["path"];
+        Querystring: TypesData["query"];
         Reply: TypesResponses;
     }>;
     complexTypes: RouteHandler<{
-        Querystring: ComplexTypesData['query'];
+        Querystring: ComplexTypesData["query"];
         Reply: ComplexTypesErrors & ComplexTypesResponses;
     }>;
     callWithResultFromHeader: RouteHandler<{
         Reply: CallWithResultFromHeaderErrors & CallWithResultFromHeaderResponses;
     }>;
     testErrorCode: RouteHandler<{
-        Querystring: TestErrorCodeData['query'];
+        Querystring: TestErrorCodeData["query"];
         Reply: TestErrorCodeErrors & TestErrorCodeResponses;
     }>;
     nonAsciiæøåÆøÅöôêÊ字符串: RouteHandler<{
-        Querystring: NonAsciiæøåÆøÅöôêÊ字符串Data['query'];
+        Querystring: NonAsciiæøåÆøÅöôêÊ字符串Data["query"];
         Reply: NonAsciiæøåÆøÅöôêÊ字符串Responses;
     }>;
     postApiVbyApiVersionBody: RouteHandler<{
-        Body: PostApiVbyApiVersionBodyData['body'];
+        Body: PostApiVbyApiVersionBodyData["body"];
         Reply: PostApiVbyApiVersionBodyErrors & PostApiVbyApiVersionBodyResponses;
     }>;
 };
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@pinia/colada/asClass/@pinia/colada.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@pinia/colada/asClass/@pinia/colada.gen.ts
index 1d845eca9..10ae99233 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@pinia/colada/asClass/@pinia/colada.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@pinia/colada/asClass/@pinia/colada.gen.ts
@@ -39,12 +39,10 @@ const createQueryKey = <TOptions extends Options>(id: string, options?: TOptions
             params.query = normalizedQuery;
         }
     }
-    return [
-        params
-    ];
+    return [params];
 };
 
-export const getFooQueryKey = (options?: Options<GetFooData>) => createQueryKey('getFoo', options);
+export const getFooQueryKey = (options?: Options<GetFooData>) => createQueryKey("getFoo", options);
 
 export const getFooQuery = defineQueryOptions((options?: Options<GetFooData>) => ({
     key: getFooQueryKey(options),
@@ -58,33 +56,29 @@ export const getFooQuery = defineQueryOptions((options?: Options<GetFooData>) =>
     }
 }));
 
-export const fooPostMutation = (options?: Partial<Options<FooPostData>>): UseMutationOptions<FooPostResponse, Options<FooPostData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await FooBazService.fooService.post({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const fooPostMutation = (options?: Partial<Options<FooPostData>>): UseMutationOptions<FooPostResponse, Options<FooPostData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await FooBazService.fooService.post({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const fooPutMutation = (options?: Partial<Options<FooPutData>>): UseMutationOptions<FooPutResponse, Options<FooPutData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await FooBazService.fooService.put({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const fooPutMutation = (options?: Partial<Options<FooPutData>>): UseMutationOptions<FooPutResponse, Options<FooPutData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await FooBazService.fooService.put({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const getFooBarQueryKey = (options?: Options<GetFooBarData>) => createQueryKey('getFooBar', options);
+export const getFooBarQueryKey = (options?: Options<GetFooBarData>) => createQueryKey("getFooBar", options);
 
 export const getFooBarQuery = defineQueryOptions((options?: Options<GetFooBarData>) => ({
     key: getFooBarQueryKey(options),
@@ -98,28 +92,24 @@ export const getFooBarQuery = defineQueryOptions((options?: Options<GetFooBarDat
     }
 }));
 
-export const fooBarPostMutation = (options?: Partial<Options<FooBarPostData>>): UseMutationOptions<FooBarPostResponse, Options<FooBarPostData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await FooBazService.fooService.barService.post({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const fooBarPostMutation = (options?: Partial<Options<FooBarPostData>>): UseMutationOptions<FooBarPostResponse, Options<FooBarPostData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await FooBazService.fooService.barService.post({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const fooBarPutMutation = (options?: Partial<Options<FooBarPutData>>): UseMutationOptions<FooBarPutResponse, Options<FooBarPutData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await FooBazService.fooService.barService.put({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const fooBarPutMutation = (options?: Partial<Options<FooBarPutData>>): UseMutationOptions<FooBarPutResponse, Options<FooBarPutData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await FooBazService.fooService.barService.put({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@pinia/colada/fetch/@pinia/colada.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@pinia/colada/fetch/@pinia/colada.gen.ts
index 5f822ac96..7c924b643 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@pinia/colada/fetch/@pinia/colada.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/@pinia/colada/fetch/@pinia/colada.gen.ts
@@ -39,12 +39,10 @@ const createQueryKey = <TOptions extends Options>(id: string, options?: TOptions
             params.query = normalizedQuery;
         }
     }
-    return [
-        params
-    ];
+    return [params];
 };
 
-export const exportQueryKey = (options?: Options<ExportData>) => createQueryKey('export', options);
+export const exportQueryKey = (options?: Options<ExportData>) => createQueryKey("export", options);
 
 export const exportQuery = defineQueryOptions((options?: Options<ExportData>) => ({
     key: exportQueryKey(options),
@@ -58,46 +56,40 @@ export const exportQuery = defineQueryOptions((options?: Options<ExportData>) =>
     }
 }));
 
-export const patchApiVbyApiVersionNoTagMutation = (options?: Partial<Options<PatchApiVbyApiVersionNoTagData>>): UseMutationOptions<unknown, Options<PatchApiVbyApiVersionNoTagData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await patchApiVbyApiVersionNoTag({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const patchApiVbyApiVersionNoTagMutation = (options?: Partial<Options<PatchApiVbyApiVersionNoTagData>>): UseMutationOptions<unknown, Options<PatchApiVbyApiVersionNoTagData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await patchApiVbyApiVersionNoTag({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const importMutation = (options?: Partial<Options<ImportData>>): UseMutationOptions<ImportResponse, Options<ImportData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await import_({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const importMutation = (options?: Partial<Options<ImportData>>): UseMutationOptions<ImportResponse, Options<ImportData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await import_({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const fooWowMutation = (options?: Partial<Options<FooWowData>>): UseMutationOptions<unknown, Options<FooWowData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await fooWow({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const fooWowMutation = (options?: Partial<Options<FooWowData>>): UseMutationOptions<unknown, Options<FooWowData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await fooWow({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const apiVVersionODataControllerCountQueryKey = (options?: Options<ApiVVersionODataControllerCountData>) => createQueryKey('apiVVersionODataControllerCount', options);
+export const apiVVersionODataControllerCountQueryKey = (options?: Options<ApiVVersionODataControllerCountData>) => createQueryKey("apiVVersionODataControllerCount", options);
 
 export const apiVVersionODataControllerCountQuery = defineQueryOptions((options?: Options<ApiVVersionODataControllerCountData>) => ({
     key: apiVVersionODataControllerCountQueryKey(options),
@@ -111,7 +103,7 @@ export const apiVVersionODataControllerCountQuery = defineQueryOptions((options?
     }
 }));
 
-export const getApiVbyApiVersionSimpleOperationQueryKey = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => createQueryKey('getApiVbyApiVersionSimpleOperation', options);
+export const getApiVbyApiVersionSimpleOperationQueryKey = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => createQueryKey("getApiVbyApiVersionSimpleOperation", options);
 
 export const getApiVbyApiVersionSimpleOperationQuery = defineQueryOptions((options: Options<GetApiVbyApiVersionSimpleOperationData>) => ({
     key: getApiVbyApiVersionSimpleOperationQueryKey(options),
@@ -125,20 +117,18 @@ export const getApiVbyApiVersionSimpleOperationQuery = defineQueryOptions((optio
     }
 }));
 
-export const deleteCallWithoutParametersAndResponseMutation = (options?: Partial<Options<DeleteCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, Options<DeleteCallWithoutParametersAndResponseData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await deleteCallWithoutParametersAndResponse({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const deleteCallWithoutParametersAndResponseMutation = (options?: Partial<Options<DeleteCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, Options<DeleteCallWithoutParametersAndResponseData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await deleteCallWithoutParametersAndResponse({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const getCallWithoutParametersAndResponseQueryKey = (options?: Options<GetCallWithoutParametersAndResponseData>) => createQueryKey('getCallWithoutParametersAndResponse', options);
+export const getCallWithoutParametersAndResponseQueryKey = (options?: Options<GetCallWithoutParametersAndResponseData>) => createQueryKey("getCallWithoutParametersAndResponse", options);
 
 export const getCallWithoutParametersAndResponseQuery = defineQueryOptions((options?: Options<GetCallWithoutParametersAndResponseData>) => ({
     key: getCallWithoutParametersAndResponseQueryKey(options),
@@ -152,114 +142,98 @@ export const getCallWithoutParametersAndResponseQuery = defineQueryOptions((opti
     }
 }));
 
-export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PatchCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, Options<PatchCallWithoutParametersAndResponseData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await patchCallWithoutParametersAndResponse({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PatchCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, Options<PatchCallWithoutParametersAndResponseData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await patchCallWithoutParametersAndResponse({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, Options<PostCallWithoutParametersAndResponseData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, Options<PostCallWithoutParametersAndResponseData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await postCallWithoutParametersAndResponse({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const putCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PutCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, Options<PutCallWithoutParametersAndResponseData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await putCallWithoutParametersAndResponse({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const putCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PutCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, Options<PutCallWithoutParametersAndResponseData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await putCallWithoutParametersAndResponse({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const deleteFooMutation = (options?: Partial<Options<DeleteFooData3>>): UseMutationOptions<unknown, Options<DeleteFooData3>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await deleteFoo({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const deleteFooMutation = (options?: Partial<Options<DeleteFooData3>>): UseMutationOptions<unknown, Options<DeleteFooData3>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await deleteFoo({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): UseMutationOptions<unknown, Options<CallWithDescriptionsData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): UseMutationOptions<unknown, Options<CallWithDescriptionsData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await callWithDescriptions({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
 /**
  * @deprecated
  */
-export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): UseMutationOptions<unknown, Options<DeprecatedCallData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await deprecatedCall({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): UseMutationOptions<unknown, Options<DeprecatedCallData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await deprecatedCall({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): UseMutationOptions<unknown, Options<CallWithParametersData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): UseMutationOptions<unknown, Options<CallWithParametersData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await callWithParameters({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): UseMutationOptions<unknown, Options<CallWithWeirdParameterNamesData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): UseMutationOptions<unknown, Options<CallWithWeirdParameterNamesData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await callWithWeirdParameterNames({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
+export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey("getCallWithOptionalParam", options);
 
 export const getCallWithOptionalParamQuery = defineQueryOptions((options: Options<GetCallWithOptionalParamData>) => ({
     key: getCallWithOptionalParamQueryKey(options),
@@ -273,46 +247,40 @@ export const getCallWithOptionalParamQuery = defineQueryOptions((options: Option
     }
 }));
 
-export const postCallWithOptionalParamMutation = (options?: Partial<Options<PostCallWithOptionalParamData>>): UseMutationOptions<PostCallWithOptionalParamResponse, Options<PostCallWithOptionalParamData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const postCallWithOptionalParamMutation = (options?: Partial<Options<PostCallWithOptionalParamData>>): UseMutationOptions<PostCallWithOptionalParamResponse, Options<PostCallWithOptionalParamData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await postCallWithOptionalParam({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Options<PostApiVbyApiVersionRequestBodyData>>): UseMutationOptions<unknown, Options<PostApiVbyApiVersionRequestBodyData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await postApiVbyApiVersionRequestBody({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Options<PostApiVbyApiVersionRequestBodyData>>): UseMutationOptions<unknown, Options<PostApiVbyApiVersionRequestBodyData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await postApiVbyApiVersionRequestBody({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const postApiVbyApiVersionFormDataMutation = (options?: Partial<Options<PostApiVbyApiVersionFormDataData>>): UseMutationOptions<unknown, Options<PostApiVbyApiVersionFormDataData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await postApiVbyApiVersionFormData({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const postApiVbyApiVersionFormDataMutation = (options?: Partial<Options<PostApiVbyApiVersionFormDataData>>): UseMutationOptions<unknown, Options<PostApiVbyApiVersionFormDataData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await postApiVbyApiVersionFormData({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const callWithDefaultParametersQueryKey = (options?: Options<CallWithDefaultParametersData>) => createQueryKey('callWithDefaultParameters', options);
+export const callWithDefaultParametersQueryKey = (options?: Options<CallWithDefaultParametersData>) => createQueryKey("callWithDefaultParameters", options);
 
 export const callWithDefaultParametersQuery = defineQueryOptions((options?: Options<CallWithDefaultParametersData>) => ({
     key: callWithDefaultParametersQueryKey(options),
@@ -326,46 +294,40 @@ export const callWithDefaultParametersQuery = defineQueryOptions((options?: Opti
     }
 }));
 
-export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): UseMutationOptions<unknown, Options<CallWithDefaultOptionalParametersData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): UseMutationOptions<unknown, Options<CallWithDefaultOptionalParametersData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await callWithDefaultOptionalParameters({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const callToTestOrderOfParamsMutation = (options?: Partial<Options<CallToTestOrderOfParamsData>>): UseMutationOptions<unknown, Options<CallToTestOrderOfParamsData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await callToTestOrderOfParams({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const callToTestOrderOfParamsMutation = (options?: Partial<Options<CallToTestOrderOfParamsData>>): UseMutationOptions<unknown, Options<CallToTestOrderOfParamsData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await callToTestOrderOfParams({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const duplicateNameMutation = (options?: Partial<Options<DuplicateNameData>>): UseMutationOptions<unknown, Options<DuplicateNameData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await duplicateName({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const duplicateNameMutation = (options?: Partial<Options<DuplicateNameData>>): UseMutationOptions<unknown, Options<DuplicateNameData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await duplicateName({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const duplicateName2QueryKey = (options?: Options<DuplicateName2Data>) => createQueryKey('duplicateName2', options);
+export const duplicateName2QueryKey = (options?: Options<DuplicateName2Data>) => createQueryKey("duplicateName2", options);
 
 export const duplicateName2Query = defineQueryOptions((options?: Options<DuplicateName2Data>) => ({
     key: duplicateName2QueryKey(options),
@@ -379,33 +341,29 @@ export const duplicateName2Query = defineQueryOptions((options?: Options<Duplica
     }
 }));
 
-export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): UseMutationOptions<unknown, Options<DuplicateName3Data>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): UseMutationOptions<unknown, Options<DuplicateName3Data>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await duplicateName3({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const duplicateName4Mutation = (options?: Partial<Options<DuplicateName4Data>>): UseMutationOptions<unknown, Options<DuplicateName4Data>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await duplicateName4({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const duplicateName4Mutation = (options?: Partial<Options<DuplicateName4Data>>): UseMutationOptions<unknown, Options<DuplicateName4Data>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await duplicateName4({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const callWithNoContentResponseQueryKey = (options?: Options<CallWithNoContentResponseData>) => createQueryKey('callWithNoContentResponse', options);
+export const callWithNoContentResponseQueryKey = (options?: Options<CallWithNoContentResponseData>) => createQueryKey("callWithNoContentResponse", options);
 
 export const callWithNoContentResponseQuery = defineQueryOptions((options?: Options<CallWithNoContentResponseData>) => ({
     key: callWithNoContentResponseQueryKey(options),
@@ -419,7 +377,7 @@ export const callWithNoContentResponseQuery = defineQueryOptions((options?: Opti
     }
 }));
 
-export const callWithResponseAndNoContentResponseQueryKey = (options?: Options<CallWithResponseAndNoContentResponseData>) => createQueryKey('callWithResponseAndNoContentResponse', options);
+export const callWithResponseAndNoContentResponseQueryKey = (options?: Options<CallWithResponseAndNoContentResponseData>) => createQueryKey("callWithResponseAndNoContentResponse", options);
 
 export const callWithResponseAndNoContentResponseQuery = defineQueryOptions((options?: Options<CallWithResponseAndNoContentResponseData>) => ({
     key: callWithResponseAndNoContentResponseQueryKey(options),
@@ -433,7 +391,7 @@ export const callWithResponseAndNoContentResponseQuery = defineQueryOptions((opt
     }
 }));
 
-export const dummyAQueryKey = (options?: Options<DummyAData>) => createQueryKey('dummyA', options);
+export const dummyAQueryKey = (options?: Options<DummyAData>) => createQueryKey("dummyA", options);
 
 export const dummyAQuery = defineQueryOptions((options?: Options<DummyAData>) => ({
     key: dummyAQueryKey(options),
@@ -447,7 +405,7 @@ export const dummyAQuery = defineQueryOptions((options?: Options<DummyAData>) =>
     }
 }));
 
-export const dummyBQueryKey = (options?: Options<DummyBData>) => createQueryKey('dummyB', options);
+export const dummyBQueryKey = (options?: Options<DummyBData>) => createQueryKey("dummyB", options);
 
 export const dummyBQuery = defineQueryOptions((options?: Options<DummyBData>) => ({
     key: dummyBQueryKey(options),
@@ -461,7 +419,7 @@ export const dummyBQuery = defineQueryOptions((options?: Options<DummyBData>) =>
     }
 }));
 
-export const callWithResponseQueryKey = (options?: Options<CallWithResponseData>) => createQueryKey('callWithResponse', options);
+export const callWithResponseQueryKey = (options?: Options<CallWithResponseData>) => createQueryKey("callWithResponse", options);
 
 export const callWithResponseQuery = defineQueryOptions((options?: Options<CallWithResponseData>) => ({
     key: callWithResponseQueryKey(options),
@@ -475,33 +433,29 @@ export const callWithResponseQuery = defineQueryOptions((options?: Options<CallW
     }
 }));
 
-export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): UseMutationOptions<CallWithDuplicateResponsesResponse, Options<CallWithDuplicateResponsesData>, CallWithDuplicateResponsesError> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): UseMutationOptions<CallWithDuplicateResponsesResponse, Options<CallWithDuplicateResponsesData>, CallWithDuplicateResponsesError> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await callWithDuplicateResponses({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const callWithResponsesMutation = (options?: Partial<Options<CallWithResponsesData>>): UseMutationOptions<CallWithResponsesResponse, Options<CallWithResponsesData>, CallWithResponsesError> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await callWithResponses({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const callWithResponsesMutation = (options?: Partial<Options<CallWithResponsesData>>): UseMutationOptions<CallWithResponsesResponse, Options<CallWithResponsesData>, CallWithResponsesError> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await callWithResponses({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const collectionFormatQueryKey = (options: Options<CollectionFormatData>) => createQueryKey('collectionFormat', options);
+export const collectionFormatQueryKey = (options: Options<CollectionFormatData>) => createQueryKey("collectionFormat", options);
 
 export const collectionFormatQuery = defineQueryOptions((options: Options<CollectionFormatData>) => ({
     key: collectionFormatQueryKey(options),
@@ -515,7 +469,7 @@ export const collectionFormatQuery = defineQueryOptions((options: Options<Collec
     }
 }));
 
-export const typesQueryKey = (options: Options<TypesData>) => createQueryKey('types', options);
+export const typesQueryKey = (options: Options<TypesData>) => createQueryKey("types", options);
 
 export const typesQuery = defineQueryOptions((options: Options<TypesData>) => ({
     key: typesQueryKey(options),
@@ -529,20 +483,18 @@ export const typesQuery = defineQueryOptions((options: Options<TypesData>) => ({
     }
 }));
 
-export const uploadFileMutation = (options?: Partial<Options<UploadFileData>>): UseMutationOptions<UploadFileResponse, Options<UploadFileData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await uploadFile({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const uploadFileMutation = (options?: Partial<Options<UploadFileData>>): UseMutationOptions<UploadFileResponse, Options<UploadFileData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await uploadFile({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const fileResponseQueryKey = (options: Options<FileResponseData>) => createQueryKey('fileResponse', options);
+export const fileResponseQueryKey = (options: Options<FileResponseData>) => createQueryKey("fileResponse", options);
 
 export const fileResponseQuery = defineQueryOptions((options: Options<FileResponseData>) => ({
     key: fileResponseQueryKey(options),
@@ -556,7 +508,7 @@ export const fileResponseQuery = defineQueryOptions((options: Options<FileRespon
     }
 }));
 
-export const complexTypesQueryKey = (options: Options<ComplexTypesData>) => createQueryKey('complexTypes', options);
+export const complexTypesQueryKey = (options: Options<ComplexTypesData>) => createQueryKey("complexTypes", options);
 
 export const complexTypesQuery = defineQueryOptions((options: Options<ComplexTypesData>) => ({
     key: complexTypesQueryKey(options),
@@ -570,7 +522,7 @@ export const complexTypesQuery = defineQueryOptions((options: Options<ComplexTyp
     }
 }));
 
-export const multipartResponseQueryKey = (options?: Options<MultipartResponseData>) => createQueryKey('multipartResponse', options);
+export const multipartResponseQueryKey = (options?: Options<MultipartResponseData>) => createQueryKey("multipartResponse", options);
 
 export const multipartResponseQuery = defineQueryOptions((options?: Options<MultipartResponseData>) => ({
     key: multipartResponseQueryKey(options),
@@ -584,83 +536,71 @@ export const multipartResponseQuery = defineQueryOptions((options?: Options<Mult
     }
 }));
 
-export const multipartRequestMutation = (options?: Partial<Options<MultipartRequestData>>): UseMutationOptions<unknown, Options<MultipartRequestData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await multipartRequest({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const multipartRequestMutation = (options?: Partial<Options<MultipartRequestData>>): UseMutationOptions<unknown, Options<MultipartRequestData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await multipartRequest({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const complexParamsMutation = (options?: Partial<Options<ComplexParamsData>>): UseMutationOptions<ComplexParamsResponse, Options<ComplexParamsData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await complexParams({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const complexParamsMutation = (options?: Partial<Options<ComplexParamsData>>): UseMutationOptions<ComplexParamsResponse, Options<ComplexParamsData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await complexParams({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): UseMutationOptions<unknown, Options<CallWithResultFromHeaderData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): UseMutationOptions<unknown, Options<CallWithResultFromHeaderData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await callWithResultFromHeader({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): UseMutationOptions<unknown, Options<TestErrorCodeData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): UseMutationOptions<unknown, Options<TestErrorCodeData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await testErrorCode({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
 /**
  * Login User
  */
-export const putWithFormUrlEncodedMutation = (options?: Partial<Options<PutWithFormUrlEncodedData>>): UseMutationOptions<unknown, Options<PutWithFormUrlEncodedData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await putWithFormUrlEncoded({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const putWithFormUrlEncodedMutation = (options?: Partial<Options<PutWithFormUrlEncodedData>>): UseMutationOptions<unknown, Options<PutWithFormUrlEncodedData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await putWithFormUrlEncoded({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/fastify/default/fastify.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/fastify/default/fastify.gen.ts
index 12b310791..769b5ee3b 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/fastify/default/fastify.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.0.x/plugins/fastify/default/fastify.gen.ts
@@ -6,63 +6,63 @@ import type { ApiVVersionODataControllerCountResponses, CallToTestOrderOfParamsD
 
 export type RouteHandlers = {
     import: RouteHandler<{
-        Body: ImportData['body'];
+        Body: ImportData["body"];
         Reply: Omit<ImportResponses, "default">;
     }>;
     apiVVersionODataControllerCount: RouteHandler<{
         Reply: ApiVVersionODataControllerCountResponses;
     }>;
     getApiVbyApiVersionSimpleOperation: RouteHandler<{
-        Params: GetApiVbyApiVersionSimpleOperationData['path'];
+        Params: GetApiVbyApiVersionSimpleOperationData["path"];
         Reply: GetApiVbyApiVersionSimpleOperationResponses;
     }>;
     deleteFoo: RouteHandler<{
-        Headers: DeleteFooData3['headers'];
-        Params: DeleteFooData3['path'];
+        Headers: DeleteFooData3["headers"];
+        Params: DeleteFooData3["path"];
     }>;
     callWithDescriptions: RouteHandler<{
-        Querystring?: CallWithDescriptionsData['query'];
+        Querystring?: CallWithDescriptionsData["query"];
     }>;
     deprecatedCall: RouteHandler<{
-        Headers: DeprecatedCallData['headers'];
+        Headers: DeprecatedCallData["headers"];
     }>;
     callWithParameters: RouteHandler<{
-        Body: CallWithParametersData['body'];
-        Headers: CallWithParametersData['headers'];
-        Params: CallWithParametersData['path'];
-        Querystring: CallWithParametersData['query'];
+        Body: CallWithParametersData["body"];
+        Headers: CallWithParametersData["headers"];
+        Params: CallWithParametersData["path"];
+        Querystring: CallWithParametersData["query"];
     }>;
     callWithWeirdParameterNames: RouteHandler<{
-        Body: CallWithWeirdParameterNamesData['body'];
-        Headers: CallWithWeirdParameterNamesData['headers'];
-        Params: CallWithWeirdParameterNamesData['path'];
-        Querystring: CallWithWeirdParameterNamesData['query'];
+        Body: CallWithWeirdParameterNamesData["body"];
+        Headers: CallWithWeirdParameterNamesData["headers"];
+        Params: CallWithWeirdParameterNamesData["path"];
+        Querystring: CallWithWeirdParameterNamesData["query"];
     }>;
     getCallWithOptionalParam: RouteHandler<{
-        Body: GetCallWithOptionalParamData['body'];
-        Querystring?: GetCallWithOptionalParamData['query'];
+        Body: GetCallWithOptionalParamData["body"];
+        Querystring?: GetCallWithOptionalParamData["query"];
     }>;
     postCallWithOptionalParam: RouteHandler<{
-        Body?: PostCallWithOptionalParamData['body'];
-        Querystring: PostCallWithOptionalParamData['query'];
+        Body?: PostCallWithOptionalParamData["body"];
+        Querystring: PostCallWithOptionalParamData["query"];
         Reply: PostCallWithOptionalParamResponses;
     }>;
     postApiVbyApiVersionRequestBody: RouteHandler<{
-        Body?: PostApiVbyApiVersionRequestBodyData['body'];
-        Querystring?: PostApiVbyApiVersionRequestBodyData['query'];
+        Body?: PostApiVbyApiVersionRequestBodyData["body"];
+        Querystring?: PostApiVbyApiVersionRequestBodyData["query"];
     }>;
     postApiVbyApiVersionFormData: RouteHandler<{
-        Body?: PostApiVbyApiVersionFormDataData['body'];
-        Querystring?: PostApiVbyApiVersionFormDataData['query'];
+        Body?: PostApiVbyApiVersionFormDataData["body"];
+        Querystring?: PostApiVbyApiVersionFormDataData["query"];
     }>;
     callWithDefaultParameters: RouteHandler<{
-        Querystring?: CallWithDefaultParametersData['query'];
+        Querystring?: CallWithDefaultParametersData["query"];
     }>;
     callWithDefaultOptionalParameters: RouteHandler<{
-        Querystring?: CallWithDefaultOptionalParametersData['query'];
+        Querystring?: CallWithDefaultOptionalParametersData["query"];
     }>;
     callToTestOrderOfParams: RouteHandler<{
-        Querystring: CallToTestOrderOfParamsData['query'];
+        Querystring: CallToTestOrderOfParamsData["query"];
     }>;
     callWithNoContentResponse: RouteHandler<{
         Reply: CallWithNoContentResponseResponses;
@@ -83,49 +83,49 @@ export type RouteHandlers = {
         Reply: Omit<CallWithResponsesErrors, "default"> & CallWithResponsesResponses;
     }>;
     collectionFormat: RouteHandler<{
-        Querystring: CollectionFormatData['query'];
+        Querystring: CollectionFormatData["query"];
     }>;
     types: RouteHandler<{
-        Params?: TypesData['path'];
-        Querystring: TypesData['query'];
+        Params?: TypesData["path"];
+        Querystring: TypesData["query"];
         Reply: TypesResponses;
     }>;
     uploadFile: RouteHandler<{
-        Body: UploadFileData['body'];
-        Params: UploadFileData['path'];
+        Body: UploadFileData["body"];
+        Params: UploadFileData["path"];
         Reply: UploadFileResponses;
     }>;
     fileResponse: RouteHandler<{
-        Params: FileResponseData['path'];
+        Params: FileResponseData["path"];
         Reply: FileResponseResponses;
     }>;
     complexTypes: RouteHandler<{
-        Querystring: ComplexTypesData['query'];
+        Querystring: ComplexTypesData["query"];
         Reply: ComplexTypesErrors & ComplexTypesResponses;
     }>;
     multipartResponse: RouteHandler<{
         Reply: MultipartResponseResponses;
     }>;
     multipartRequest: RouteHandler<{
-        Body?: MultipartRequestData['body'];
+        Body?: MultipartRequestData["body"];
     }>;
     complexParams: RouteHandler<{
-        Body?: ComplexParamsData['body'];
-        Params: ComplexParamsData['path'];
+        Body?: ComplexParamsData["body"];
+        Params: ComplexParamsData["path"];
         Reply: ComplexParamsResponses;
     }>;
     callWithResultFromHeader: RouteHandler<{
         Reply: CallWithResultFromHeaderErrors & CallWithResultFromHeaderResponses;
     }>;
     testErrorCode: RouteHandler<{
-        Querystring: TestErrorCodeData['query'];
+        Querystring: TestErrorCodeData["query"];
         Reply: TestErrorCodeErrors & TestErrorCodeResponses;
     }>;
     nonAsciiæøåÆøÅöôêÊ字符串: RouteHandler<{
-        Querystring: NonAsciiæøåÆøÅöôêÊ字符串Data['query'];
+        Querystring: NonAsciiæøåÆøÅöôêÊ字符串Data["query"];
         Reply: NonAsciiæøåÆøÅöôêÊ字符串Responses;
     }>;
     putWithFormUrlEncoded: RouteHandler<{
-        Body: PutWithFormUrlEncodedData['body'];
+        Body: PutWithFormUrlEncodedData["body"];
     }>;
 };
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@pinia/colada/asClass/@pinia/colada.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@pinia/colada/asClass/@pinia/colada.gen.ts
index 1d845eca9..10ae99233 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@pinia/colada/asClass/@pinia/colada.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@pinia/colada/asClass/@pinia/colada.gen.ts
@@ -39,12 +39,10 @@ const createQueryKey = <TOptions extends Options>(id: string, options?: TOptions
             params.query = normalizedQuery;
         }
     }
-    return [
-        params
-    ];
+    return [params];
 };
 
-export const getFooQueryKey = (options?: Options<GetFooData>) => createQueryKey('getFoo', options);
+export const getFooQueryKey = (options?: Options<GetFooData>) => createQueryKey("getFoo", options);
 
 export const getFooQuery = defineQueryOptions((options?: Options<GetFooData>) => ({
     key: getFooQueryKey(options),
@@ -58,33 +56,29 @@ export const getFooQuery = defineQueryOptions((options?: Options<GetFooData>) =>
     }
 }));
 
-export const fooPostMutation = (options?: Partial<Options<FooPostData>>): UseMutationOptions<FooPostResponse, Options<FooPostData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await FooBazService.fooService.post({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const fooPostMutation = (options?: Partial<Options<FooPostData>>): UseMutationOptions<FooPostResponse, Options<FooPostData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await FooBazService.fooService.post({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const fooPutMutation = (options?: Partial<Options<FooPutData>>): UseMutationOptions<FooPutResponse, Options<FooPutData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await FooBazService.fooService.put({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const fooPutMutation = (options?: Partial<Options<FooPutData>>): UseMutationOptions<FooPutResponse, Options<FooPutData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await FooBazService.fooService.put({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const getFooBarQueryKey = (options?: Options<GetFooBarData>) => createQueryKey('getFooBar', options);
+export const getFooBarQueryKey = (options?: Options<GetFooBarData>) => createQueryKey("getFooBar", options);
 
 export const getFooBarQuery = defineQueryOptions((options?: Options<GetFooBarData>) => ({
     key: getFooBarQueryKey(options),
@@ -98,28 +92,24 @@ export const getFooBarQuery = defineQueryOptions((options?: Options<GetFooBarDat
     }
 }));
 
-export const fooBarPostMutation = (options?: Partial<Options<FooBarPostData>>): UseMutationOptions<FooBarPostResponse, Options<FooBarPostData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await FooBazService.fooService.barService.post({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const fooBarPostMutation = (options?: Partial<Options<FooBarPostData>>): UseMutationOptions<FooBarPostResponse, Options<FooBarPostData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await FooBazService.fooService.barService.post({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const fooBarPutMutation = (options?: Partial<Options<FooBarPutData>>): UseMutationOptions<FooBarPutResponse, Options<FooBarPutData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await FooBazService.fooService.barService.put({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const fooBarPutMutation = (options?: Partial<Options<FooBarPutData>>): UseMutationOptions<FooBarPutResponse, Options<FooBarPutData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await FooBazService.fooService.barService.put({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@pinia/colada/fetch/@pinia/colada.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@pinia/colada/fetch/@pinia/colada.gen.ts
index 5f822ac96..7c924b643 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@pinia/colada/fetch/@pinia/colada.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/@pinia/colada/fetch/@pinia/colada.gen.ts
@@ -39,12 +39,10 @@ const createQueryKey = <TOptions extends Options>(id: string, options?: TOptions
             params.query = normalizedQuery;
         }
     }
-    return [
-        params
-    ];
+    return [params];
 };
 
-export const exportQueryKey = (options?: Options<ExportData>) => createQueryKey('export', options);
+export const exportQueryKey = (options?: Options<ExportData>) => createQueryKey("export", options);
 
 export const exportQuery = defineQueryOptions((options?: Options<ExportData>) => ({
     key: exportQueryKey(options),
@@ -58,46 +56,40 @@ export const exportQuery = defineQueryOptions((options?: Options<ExportData>) =>
     }
 }));
 
-export const patchApiVbyApiVersionNoTagMutation = (options?: Partial<Options<PatchApiVbyApiVersionNoTagData>>): UseMutationOptions<unknown, Options<PatchApiVbyApiVersionNoTagData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await patchApiVbyApiVersionNoTag({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const patchApiVbyApiVersionNoTagMutation = (options?: Partial<Options<PatchApiVbyApiVersionNoTagData>>): UseMutationOptions<unknown, Options<PatchApiVbyApiVersionNoTagData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await patchApiVbyApiVersionNoTag({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const importMutation = (options?: Partial<Options<ImportData>>): UseMutationOptions<ImportResponse, Options<ImportData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await import_({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const importMutation = (options?: Partial<Options<ImportData>>): UseMutationOptions<ImportResponse, Options<ImportData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await import_({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const fooWowMutation = (options?: Partial<Options<FooWowData>>): UseMutationOptions<unknown, Options<FooWowData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await fooWow({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const fooWowMutation = (options?: Partial<Options<FooWowData>>): UseMutationOptions<unknown, Options<FooWowData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await fooWow({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const apiVVersionODataControllerCountQueryKey = (options?: Options<ApiVVersionODataControllerCountData>) => createQueryKey('apiVVersionODataControllerCount', options);
+export const apiVVersionODataControllerCountQueryKey = (options?: Options<ApiVVersionODataControllerCountData>) => createQueryKey("apiVVersionODataControllerCount", options);
 
 export const apiVVersionODataControllerCountQuery = defineQueryOptions((options?: Options<ApiVVersionODataControllerCountData>) => ({
     key: apiVVersionODataControllerCountQueryKey(options),
@@ -111,7 +103,7 @@ export const apiVVersionODataControllerCountQuery = defineQueryOptions((options?
     }
 }));
 
-export const getApiVbyApiVersionSimpleOperationQueryKey = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => createQueryKey('getApiVbyApiVersionSimpleOperation', options);
+export const getApiVbyApiVersionSimpleOperationQueryKey = (options: Options<GetApiVbyApiVersionSimpleOperationData>) => createQueryKey("getApiVbyApiVersionSimpleOperation", options);
 
 export const getApiVbyApiVersionSimpleOperationQuery = defineQueryOptions((options: Options<GetApiVbyApiVersionSimpleOperationData>) => ({
     key: getApiVbyApiVersionSimpleOperationQueryKey(options),
@@ -125,20 +117,18 @@ export const getApiVbyApiVersionSimpleOperationQuery = defineQueryOptions((optio
     }
 }));
 
-export const deleteCallWithoutParametersAndResponseMutation = (options?: Partial<Options<DeleteCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, Options<DeleteCallWithoutParametersAndResponseData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await deleteCallWithoutParametersAndResponse({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const deleteCallWithoutParametersAndResponseMutation = (options?: Partial<Options<DeleteCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, Options<DeleteCallWithoutParametersAndResponseData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await deleteCallWithoutParametersAndResponse({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const getCallWithoutParametersAndResponseQueryKey = (options?: Options<GetCallWithoutParametersAndResponseData>) => createQueryKey('getCallWithoutParametersAndResponse', options);
+export const getCallWithoutParametersAndResponseQueryKey = (options?: Options<GetCallWithoutParametersAndResponseData>) => createQueryKey("getCallWithoutParametersAndResponse", options);
 
 export const getCallWithoutParametersAndResponseQuery = defineQueryOptions((options?: Options<GetCallWithoutParametersAndResponseData>) => ({
     key: getCallWithoutParametersAndResponseQueryKey(options),
@@ -152,114 +142,98 @@ export const getCallWithoutParametersAndResponseQuery = defineQueryOptions((opti
     }
 }));
 
-export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PatchCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, Options<PatchCallWithoutParametersAndResponseData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await patchCallWithoutParametersAndResponse({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const patchCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PatchCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, Options<PatchCallWithoutParametersAndResponseData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await patchCallWithoutParametersAndResponse({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, Options<PostCallWithoutParametersAndResponseData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await postCallWithoutParametersAndResponse({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const postCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PostCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, Options<PostCallWithoutParametersAndResponseData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await postCallWithoutParametersAndResponse({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const putCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PutCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, Options<PutCallWithoutParametersAndResponseData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await putCallWithoutParametersAndResponse({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const putCallWithoutParametersAndResponseMutation = (options?: Partial<Options<PutCallWithoutParametersAndResponseData>>): UseMutationOptions<unknown, Options<PutCallWithoutParametersAndResponseData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await putCallWithoutParametersAndResponse({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const deleteFooMutation = (options?: Partial<Options<DeleteFooData3>>): UseMutationOptions<unknown, Options<DeleteFooData3>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await deleteFoo({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const deleteFooMutation = (options?: Partial<Options<DeleteFooData3>>): UseMutationOptions<unknown, Options<DeleteFooData3>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await deleteFoo({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): UseMutationOptions<unknown, Options<CallWithDescriptionsData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await callWithDescriptions({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const callWithDescriptionsMutation = (options?: Partial<Options<CallWithDescriptionsData>>): UseMutationOptions<unknown, Options<CallWithDescriptionsData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await callWithDescriptions({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
 /**
  * @deprecated
  */
-export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): UseMutationOptions<unknown, Options<DeprecatedCallData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await deprecatedCall({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const deprecatedCallMutation = (options?: Partial<Options<DeprecatedCallData>>): UseMutationOptions<unknown, Options<DeprecatedCallData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await deprecatedCall({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): UseMutationOptions<unknown, Options<CallWithParametersData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await callWithParameters({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const callWithParametersMutation = (options?: Partial<Options<CallWithParametersData>>): UseMutationOptions<unknown, Options<CallWithParametersData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await callWithParameters({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): UseMutationOptions<unknown, Options<CallWithWeirdParameterNamesData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await callWithWeirdParameterNames({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const callWithWeirdParameterNamesMutation = (options?: Partial<Options<CallWithWeirdParameterNamesData>>): UseMutationOptions<unknown, Options<CallWithWeirdParameterNamesData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await callWithWeirdParameterNames({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey('getCallWithOptionalParam', options);
+export const getCallWithOptionalParamQueryKey = (options: Options<GetCallWithOptionalParamData>) => createQueryKey("getCallWithOptionalParam", options);
 
 export const getCallWithOptionalParamQuery = defineQueryOptions((options: Options<GetCallWithOptionalParamData>) => ({
     key: getCallWithOptionalParamQueryKey(options),
@@ -273,46 +247,40 @@ export const getCallWithOptionalParamQuery = defineQueryOptions((options: Option
     }
 }));
 
-export const postCallWithOptionalParamMutation = (options?: Partial<Options<PostCallWithOptionalParamData>>): UseMutationOptions<PostCallWithOptionalParamResponse, Options<PostCallWithOptionalParamData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await postCallWithOptionalParam({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const postCallWithOptionalParamMutation = (options?: Partial<Options<PostCallWithOptionalParamData>>): UseMutationOptions<PostCallWithOptionalParamResponse, Options<PostCallWithOptionalParamData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await postCallWithOptionalParam({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Options<PostApiVbyApiVersionRequestBodyData>>): UseMutationOptions<unknown, Options<PostApiVbyApiVersionRequestBodyData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await postApiVbyApiVersionRequestBody({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const postApiVbyApiVersionRequestBodyMutation = (options?: Partial<Options<PostApiVbyApiVersionRequestBodyData>>): UseMutationOptions<unknown, Options<PostApiVbyApiVersionRequestBodyData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await postApiVbyApiVersionRequestBody({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const postApiVbyApiVersionFormDataMutation = (options?: Partial<Options<PostApiVbyApiVersionFormDataData>>): UseMutationOptions<unknown, Options<PostApiVbyApiVersionFormDataData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await postApiVbyApiVersionFormData({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const postApiVbyApiVersionFormDataMutation = (options?: Partial<Options<PostApiVbyApiVersionFormDataData>>): UseMutationOptions<unknown, Options<PostApiVbyApiVersionFormDataData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await postApiVbyApiVersionFormData({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const callWithDefaultParametersQueryKey = (options?: Options<CallWithDefaultParametersData>) => createQueryKey('callWithDefaultParameters', options);
+export const callWithDefaultParametersQueryKey = (options?: Options<CallWithDefaultParametersData>) => createQueryKey("callWithDefaultParameters", options);
 
 export const callWithDefaultParametersQuery = defineQueryOptions((options?: Options<CallWithDefaultParametersData>) => ({
     key: callWithDefaultParametersQueryKey(options),
@@ -326,46 +294,40 @@ export const callWithDefaultParametersQuery = defineQueryOptions((options?: Opti
     }
 }));
 
-export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): UseMutationOptions<unknown, Options<CallWithDefaultOptionalParametersData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await callWithDefaultOptionalParameters({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const callWithDefaultOptionalParametersMutation = (options?: Partial<Options<CallWithDefaultOptionalParametersData>>): UseMutationOptions<unknown, Options<CallWithDefaultOptionalParametersData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await callWithDefaultOptionalParameters({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const callToTestOrderOfParamsMutation = (options?: Partial<Options<CallToTestOrderOfParamsData>>): UseMutationOptions<unknown, Options<CallToTestOrderOfParamsData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await callToTestOrderOfParams({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const callToTestOrderOfParamsMutation = (options?: Partial<Options<CallToTestOrderOfParamsData>>): UseMutationOptions<unknown, Options<CallToTestOrderOfParamsData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await callToTestOrderOfParams({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const duplicateNameMutation = (options?: Partial<Options<DuplicateNameData>>): UseMutationOptions<unknown, Options<DuplicateNameData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await duplicateName({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const duplicateNameMutation = (options?: Partial<Options<DuplicateNameData>>): UseMutationOptions<unknown, Options<DuplicateNameData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await duplicateName({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const duplicateName2QueryKey = (options?: Options<DuplicateName2Data>) => createQueryKey('duplicateName2', options);
+export const duplicateName2QueryKey = (options?: Options<DuplicateName2Data>) => createQueryKey("duplicateName2", options);
 
 export const duplicateName2Query = defineQueryOptions((options?: Options<DuplicateName2Data>) => ({
     key: duplicateName2QueryKey(options),
@@ -379,33 +341,29 @@ export const duplicateName2Query = defineQueryOptions((options?: Options<Duplica
     }
 }));
 
-export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): UseMutationOptions<unknown, Options<DuplicateName3Data>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await duplicateName3({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const duplicateName3Mutation = (options?: Partial<Options<DuplicateName3Data>>): UseMutationOptions<unknown, Options<DuplicateName3Data>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await duplicateName3({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const duplicateName4Mutation = (options?: Partial<Options<DuplicateName4Data>>): UseMutationOptions<unknown, Options<DuplicateName4Data>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await duplicateName4({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const duplicateName4Mutation = (options?: Partial<Options<DuplicateName4Data>>): UseMutationOptions<unknown, Options<DuplicateName4Data>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await duplicateName4({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const callWithNoContentResponseQueryKey = (options?: Options<CallWithNoContentResponseData>) => createQueryKey('callWithNoContentResponse', options);
+export const callWithNoContentResponseQueryKey = (options?: Options<CallWithNoContentResponseData>) => createQueryKey("callWithNoContentResponse", options);
 
 export const callWithNoContentResponseQuery = defineQueryOptions((options?: Options<CallWithNoContentResponseData>) => ({
     key: callWithNoContentResponseQueryKey(options),
@@ -419,7 +377,7 @@ export const callWithNoContentResponseQuery = defineQueryOptions((options?: Opti
     }
 }));
 
-export const callWithResponseAndNoContentResponseQueryKey = (options?: Options<CallWithResponseAndNoContentResponseData>) => createQueryKey('callWithResponseAndNoContentResponse', options);
+export const callWithResponseAndNoContentResponseQueryKey = (options?: Options<CallWithResponseAndNoContentResponseData>) => createQueryKey("callWithResponseAndNoContentResponse", options);
 
 export const callWithResponseAndNoContentResponseQuery = defineQueryOptions((options?: Options<CallWithResponseAndNoContentResponseData>) => ({
     key: callWithResponseAndNoContentResponseQueryKey(options),
@@ -433,7 +391,7 @@ export const callWithResponseAndNoContentResponseQuery = defineQueryOptions((opt
     }
 }));
 
-export const dummyAQueryKey = (options?: Options<DummyAData>) => createQueryKey('dummyA', options);
+export const dummyAQueryKey = (options?: Options<DummyAData>) => createQueryKey("dummyA", options);
 
 export const dummyAQuery = defineQueryOptions((options?: Options<DummyAData>) => ({
     key: dummyAQueryKey(options),
@@ -447,7 +405,7 @@ export const dummyAQuery = defineQueryOptions((options?: Options<DummyAData>) =>
     }
 }));
 
-export const dummyBQueryKey = (options?: Options<DummyBData>) => createQueryKey('dummyB', options);
+export const dummyBQueryKey = (options?: Options<DummyBData>) => createQueryKey("dummyB", options);
 
 export const dummyBQuery = defineQueryOptions((options?: Options<DummyBData>) => ({
     key: dummyBQueryKey(options),
@@ -461,7 +419,7 @@ export const dummyBQuery = defineQueryOptions((options?: Options<DummyBData>) =>
     }
 }));
 
-export const callWithResponseQueryKey = (options?: Options<CallWithResponseData>) => createQueryKey('callWithResponse', options);
+export const callWithResponseQueryKey = (options?: Options<CallWithResponseData>) => createQueryKey("callWithResponse", options);
 
 export const callWithResponseQuery = defineQueryOptions((options?: Options<CallWithResponseData>) => ({
     key: callWithResponseQueryKey(options),
@@ -475,33 +433,29 @@ export const callWithResponseQuery = defineQueryOptions((options?: Options<CallW
     }
 }));
 
-export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): UseMutationOptions<CallWithDuplicateResponsesResponse, Options<CallWithDuplicateResponsesData>, CallWithDuplicateResponsesError> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await callWithDuplicateResponses({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const callWithDuplicateResponsesMutation = (options?: Partial<Options<CallWithDuplicateResponsesData>>): UseMutationOptions<CallWithDuplicateResponsesResponse, Options<CallWithDuplicateResponsesData>, CallWithDuplicateResponsesError> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await callWithDuplicateResponses({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const callWithResponsesMutation = (options?: Partial<Options<CallWithResponsesData>>): UseMutationOptions<CallWithResponsesResponse, Options<CallWithResponsesData>, CallWithResponsesError> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await callWithResponses({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const callWithResponsesMutation = (options?: Partial<Options<CallWithResponsesData>>): UseMutationOptions<CallWithResponsesResponse, Options<CallWithResponsesData>, CallWithResponsesError> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await callWithResponses({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const collectionFormatQueryKey = (options: Options<CollectionFormatData>) => createQueryKey('collectionFormat', options);
+export const collectionFormatQueryKey = (options: Options<CollectionFormatData>) => createQueryKey("collectionFormat", options);
 
 export const collectionFormatQuery = defineQueryOptions((options: Options<CollectionFormatData>) => ({
     key: collectionFormatQueryKey(options),
@@ -515,7 +469,7 @@ export const collectionFormatQuery = defineQueryOptions((options: Options<Collec
     }
 }));
 
-export const typesQueryKey = (options: Options<TypesData>) => createQueryKey('types', options);
+export const typesQueryKey = (options: Options<TypesData>) => createQueryKey("types", options);
 
 export const typesQuery = defineQueryOptions((options: Options<TypesData>) => ({
     key: typesQueryKey(options),
@@ -529,20 +483,18 @@ export const typesQuery = defineQueryOptions((options: Options<TypesData>) => ({
     }
 }));
 
-export const uploadFileMutation = (options?: Partial<Options<UploadFileData>>): UseMutationOptions<UploadFileResponse, Options<UploadFileData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await uploadFile({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const uploadFileMutation = (options?: Partial<Options<UploadFileData>>): UseMutationOptions<UploadFileResponse, Options<UploadFileData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await uploadFile({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const fileResponseQueryKey = (options: Options<FileResponseData>) => createQueryKey('fileResponse', options);
+export const fileResponseQueryKey = (options: Options<FileResponseData>) => createQueryKey("fileResponse", options);
 
 export const fileResponseQuery = defineQueryOptions((options: Options<FileResponseData>) => ({
     key: fileResponseQueryKey(options),
@@ -556,7 +508,7 @@ export const fileResponseQuery = defineQueryOptions((options: Options<FileRespon
     }
 }));
 
-export const complexTypesQueryKey = (options: Options<ComplexTypesData>) => createQueryKey('complexTypes', options);
+export const complexTypesQueryKey = (options: Options<ComplexTypesData>) => createQueryKey("complexTypes", options);
 
 export const complexTypesQuery = defineQueryOptions((options: Options<ComplexTypesData>) => ({
     key: complexTypesQueryKey(options),
@@ -570,7 +522,7 @@ export const complexTypesQuery = defineQueryOptions((options: Options<ComplexTyp
     }
 }));
 
-export const multipartResponseQueryKey = (options?: Options<MultipartResponseData>) => createQueryKey('multipartResponse', options);
+export const multipartResponseQueryKey = (options?: Options<MultipartResponseData>) => createQueryKey("multipartResponse", options);
 
 export const multipartResponseQuery = defineQueryOptions((options?: Options<MultipartResponseData>) => ({
     key: multipartResponseQueryKey(options),
@@ -584,83 +536,71 @@ export const multipartResponseQuery = defineQueryOptions((options?: Options<Mult
     }
 }));
 
-export const multipartRequestMutation = (options?: Partial<Options<MultipartRequestData>>): UseMutationOptions<unknown, Options<MultipartRequestData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await multipartRequest({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const multipartRequestMutation = (options?: Partial<Options<MultipartRequestData>>): UseMutationOptions<unknown, Options<MultipartRequestData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await multipartRequest({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const complexParamsMutation = (options?: Partial<Options<ComplexParamsData>>): UseMutationOptions<ComplexParamsResponse, Options<ComplexParamsData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await complexParams({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const complexParamsMutation = (options?: Partial<Options<ComplexParamsData>>): UseMutationOptions<ComplexParamsResponse, Options<ComplexParamsData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await complexParams({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): UseMutationOptions<unknown, Options<CallWithResultFromHeaderData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await callWithResultFromHeader({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const callWithResultFromHeaderMutation = (options?: Partial<Options<CallWithResultFromHeaderData>>): UseMutationOptions<unknown, Options<CallWithResultFromHeaderData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await callWithResultFromHeader({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): UseMutationOptions<unknown, Options<TestErrorCodeData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await testErrorCode({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const testErrorCodeMutation = (options?: Partial<Options<TestErrorCodeData>>): UseMutationOptions<unknown, Options<TestErrorCodeData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await testErrorCode({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
-export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const nonAsciiæøåÆøÅöôêÊ字符串Mutation = (options?: Partial<Options<NonAsciiæøåÆøÅöôêÊ字符串Data>>): UseMutationOptions<NonAsciiæøåÆøÅöôêÊ字符串Response, Options<NonAsciiæøåÆøÅöôêÊ字符串Data>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
 
 /**
  * Login User
  */
-export const putWithFormUrlEncodedMutation = (options?: Partial<Options<PutWithFormUrlEncodedData>>): UseMutationOptions<unknown, Options<PutWithFormUrlEncodedData>, Error> => {
-    return {
-        mutation: async (fnOptions) => {
-            const { data } = await putWithFormUrlEncoded({
-                ...options,
-                ...fnOptions,
-                throwOnError: true
-            });
-            return data;
-        }
-    };
-};
+export const putWithFormUrlEncodedMutation = (options?: Partial<Options<PutWithFormUrlEncodedData>>): UseMutationOptions<unknown, Options<PutWithFormUrlEncodedData>, Error> => ({
+    mutation: async (fnOptions) => {
+        const { data } = await putWithFormUrlEncoded({
+            ...options,
+            ...fnOptions,
+            throwOnError: true
+        });
+        return data;
+    }
+});
diff --git a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/fastify/default/fastify.gen.ts b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/fastify/default/fastify.gen.ts
index 12b310791..769b5ee3b 100644
--- a/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/fastify/default/fastify.gen.ts
+++ b/packages/openapi-ts-tests/main/test/__snapshots__/3.1.x/plugins/fastify/default/fastify.gen.ts
@@ -6,63 +6,63 @@ import type { ApiVVersionODataControllerCountResponses, CallToTestOrderOfParamsD
 
 export type RouteHandlers = {
     import: RouteHandler<{
-        Body: ImportData['body'];
+        Body: ImportData["body"];
         Reply: Omit<ImportResponses, "default">;
     }>;
     apiVVersionODataControllerCount: RouteHandler<{
         Reply: ApiVVersionODataControllerCountResponses;
     }>;
     getApiVbyApiVersionSimpleOperation: RouteHandler<{
-        Params: GetApiVbyApiVersionSimpleOperationData['path'];
+        Params: GetApiVbyApiVersionSimpleOperationData["path"];
         Reply: GetApiVbyApiVersionSimpleOperationResponses;
     }>;
     deleteFoo: RouteHandler<{
-        Headers: DeleteFooData3['headers'];
-        Params: DeleteFooData3['path'];
+        Headers: DeleteFooData3["headers"];
+        Params: DeleteFooData3["path"];
     }>;
     callWithDescriptions: RouteHandler<{
-        Querystring?: CallWithDescriptionsData['query'];
+        Querystring?: CallWithDescriptionsData["query"];
     }>;
     deprecatedCall: RouteHandler<{
-        Headers: DeprecatedCallData['headers'];
+        Headers: DeprecatedCallData["headers"];
     }>;
     callWithParameters: RouteHandler<{
-        Body: CallWithParametersData['body'];
-        Headers: CallWithParametersData['headers'];
-        Params: CallWithParametersData['path'];
-        Querystring: CallWithParametersData['query'];
+        Body: CallWithParametersData["body"];
+        Headers: CallWithParametersData["headers"];
+        Params: CallWithParametersData["path"];
+        Querystring: CallWithParametersData["query"];
     }>;
     callWithWeirdParameterNames: RouteHandler<{
-        Body: CallWithWeirdParameterNamesData['body'];
-        Headers: CallWithWeirdParameterNamesData['headers'];
-        Params: CallWithWeirdParameterNamesData['path'];
-        Querystring: CallWithWeirdParameterNamesData['query'];
+        Body: CallWithWeirdParameterNamesData["body"];
+        Headers: CallWithWeirdParameterNamesData["headers"];
+        Params: CallWithWeirdParameterNamesData["path"];
+        Querystring: CallWithWeirdParameterNamesData["query"];
     }>;
     getCallWithOptionalParam: RouteHandler<{
-        Body: GetCallWithOptionalParamData['body'];
-        Querystring?: GetCallWithOptionalParamData['query'];
+        Body: GetCallWithOptionalParamData["body"];
+        Querystring?: GetCallWithOptionalParamData["query"];
     }>;
     postCallWithOptionalParam: RouteHandler<{
-        Body?: PostCallWithOptionalParamData['body'];
-        Querystring: PostCallWithOptionalParamData['query'];
+        Body?: PostCallWithOptionalParamData["body"];
+        Querystring: PostCallWithOptionalParamData["query"];
         Reply: PostCallWithOptionalParamResponses;
     }>;
     postApiVbyApiVersionRequestBody: RouteHandler<{
-        Body?: PostApiVbyApiVersionRequestBodyData['body'];
-        Querystring?: PostApiVbyApiVersionRequestBodyData['query'];
+        Body?: PostApiVbyApiVersionRequestBodyData["body"];
+        Querystring?: PostApiVbyApiVersionRequestBodyData["query"];
     }>;
     postApiVbyApiVersionFormData: RouteHandler<{
-        Body?: PostApiVbyApiVersionFormDataData['body'];
-        Querystring?: PostApiVbyApiVersionFormDataData['query'];
+        Body?: PostApiVbyApiVersionFormDataData["body"];
+        Querystring?: PostApiVbyApiVersionFormDataData["query"];
     }>;
     callWithDefaultParameters: RouteHandler<{
-        Querystring?: CallWithDefaultParametersData['query'];
+        Querystring?: CallWithDefaultParametersData["query"];
     }>;
     callWithDefaultOptionalParameters: RouteHandler<{
-        Querystring?: CallWithDefaultOptionalParametersData['query'];
+        Querystring?: CallWithDefaultOptionalParametersData["query"];
     }>;
     callToTestOrderOfParams: RouteHandler<{
-        Querystring: CallToTestOrderOfParamsData['query'];
+        Querystring: CallToTestOrderOfParamsData["query"];
     }>;
     callWithNoContentResponse: RouteHandler<{
         Reply: CallWithNoContentResponseResponses;
@@ -83,49 +83,49 @@ export type RouteHandlers = {
         Reply: Omit<CallWithResponsesErrors, "default"> & CallWithResponsesResponses;
     }>;
     collectionFormat: RouteHandler<{
-        Querystring: CollectionFormatData['query'];
+        Querystring: CollectionFormatData["query"];
     }>;
     types: RouteHandler<{
-        Params?: TypesData['path'];
-        Querystring: TypesData['query'];
+        Params?: TypesData["path"];
+        Querystring: TypesData["query"];
         Reply: TypesResponses;
     }>;
     uploadFile: RouteHandler<{
-        Body: UploadFileData['body'];
-        Params: UploadFileData['path'];
+        Body: UploadFileData["body"];
+        Params: UploadFileData["path"];
         Reply: UploadFileResponses;
     }>;
     fileResponse: RouteHandler<{
-        Params: FileResponseData['path'];
+        Params: FileResponseData["path"];
         Reply: FileResponseResponses;
     }>;
     complexTypes: RouteHandler<{
-        Querystring: ComplexTypesData['query'];
+        Querystring: ComplexTypesData["query"];
         Reply: ComplexTypesErrors & ComplexTypesResponses;
     }>;
     multipartResponse: RouteHandler<{
         Reply: MultipartResponseResponses;
     }>;
     multipartRequest: RouteHandler<{
-        Body?: MultipartRequestData['body'];
+        Body?: MultipartRequestData["body"];
     }>;
     complexParams: RouteHandler<{
-        Body?: ComplexParamsData['body'];
-        Params: ComplexParamsData['path'];
+        Body?: ComplexParamsData["body"];
+        Params: ComplexParamsData["path"];
         Reply: ComplexParamsResponses;
     }>;
     callWithResultFromHeader: RouteHandler<{
         Reply: CallWithResultFromHeaderErrors & CallWithResultFromHeaderResponses;
     }>;
     testErrorCode: RouteHandler<{
-        Querystring: TestErrorCodeData['query'];
+        Querystring: TestErrorCodeData["query"];
         Reply: TestErrorCodeErrors & TestErrorCodeResponses;
     }>;
     nonAsciiæøåÆøÅöôêÊ字符串: RouteHandler<{
-        Querystring: NonAsciiæøåÆøÅöôêÊ字符串Data['query'];
+        Querystring: NonAsciiæøåÆøÅöôêÊ字符串Data["query"];
         Reply: NonAsciiæøåÆøÅöôêÊ字符串Responses;
     }>;
     putWithFormUrlEncoded: RouteHandler<{
-        Body: PutWithFormUrlEncodedData['body'];
+        Body: PutWithFormUrlEncodedData["body"];
     }>;
 };
diff --git a/packages/openapi-ts/src/plugins/@angular/common/httpRequests.ts b/packages/openapi-ts/src/plugins/@angular/common/httpRequests.ts
index a49399f63..1da2efb65 100644
--- a/packages/openapi-ts/src/plugins/@angular/common/httpRequests.ts
+++ b/packages/openapi-ts/src/plugins/@angular/common/httpRequests.ts
@@ -265,12 +265,10 @@ const generateAngularRequestMethod = ({
 
   return $.method(methodName)
     .public()
-    .$if(createOperationComment({ operation }), (c, v) =>
-      c.doc(v as ReadonlyArray<string>),
-    )
+    .$if(createOperationComment(operation), (c, v) => c.doc(v))
     .param('options', (p) =>
       p
-        .optional(!isRequiredOptions)
+        .required(isRequiredOptions)
         .type(`${symbolOptions.placeholder}<${dataType}, ThrowOnError>`),
     )
     .generic('ThrowOnError', (g) => g.extends('boolean').default(false))
@@ -318,14 +316,12 @@ const generateAngularRequestFunction = ({
 
   return $.const(symbol.placeholder)
     .export(symbol.exported)
-    .$if(createOperationComment({ operation }), (c, v) =>
-      c.doc(v as ReadonlyArray<string>),
-    )
+    .$if(createOperationComment(operation), (c, v) => c.doc(v))
     .assign(
       $.func()
         .param('options', (p) =>
           p
-            .optional(!isRequiredOptions)
+            .required(isRequiredOptions)
             .type(`${symbolOptions.placeholder}<${dataType}, ThrowOnError>`),
         )
         .generic('ThrowOnError', (g) => g.extends('boolean').default(false))
diff --git a/packages/openapi-ts/src/plugins/@angular/common/httpResources.ts b/packages/openapi-ts/src/plugins/@angular/common/httpResources.ts
index 79e65ce06..be5ecd8ec 100644
--- a/packages/openapi-ts/src/plugins/@angular/common/httpResources.ts
+++ b/packages/openapi-ts/src/plugins/@angular/common/httpResources.ts
@@ -342,12 +342,10 @@ const generateAngularResourceMethod = ({
 
   return $.method(methodName)
     .public()
-    .$if(createOperationComment({ operation }), (c, v) =>
-      c.doc(v as ReadonlyArray<string>),
-    )
+    .$if(createOperationComment(operation), (c, v) => c.doc(v))
     .param('options', (p) =>
       p
-        .optional(!isRequiredOptions)
+        .required(isRequiredOptions)
         .type(
           `() => ${symbolOptions.placeholder}<${dataType}, ThrowOnError> | undefined`,
         ),
@@ -391,14 +389,12 @@ const generateAngularResourceFunction = ({
 
   return $.const(symbol.placeholder)
     .export(symbol.exported)
-    .$if(createOperationComment({ operation }), (c, v) =>
-      c.doc(v as ReadonlyArray<string>),
-    )
+    .$if(createOperationComment(operation), (c, v) => c.doc(v))
     .assign(
       $.func()
         .param('options', (p) =>
           p
-            .optional(!isRequiredOptions)
+            .required(isRequiredOptions)
             .type(
               `() => ${symbolOptions.placeholder}<${dataType}, ThrowOnError> | undefined`,
             ),
diff --git a/packages/openapi-ts/src/plugins/@hey-api/sdk/shared/class.ts b/packages/openapi-ts/src/plugins/@hey-api/sdk/shared/class.ts
index 4621c60ff..6e607ad8f 100644
--- a/packages/openapi-ts/src/plugins/@hey-api/sdk/shared/class.ts
+++ b/packages/openapi-ts/src/plugins/@hey-api/sdk/shared/class.ts
@@ -255,9 +255,7 @@ export const generateClassSdk = ({
           });
           const functionNode = $.method(entry.methodName, (m) =>
             m
-              .$if(createOperationComment({ operation }), (m, v) =>
-                m.doc(v as ReadonlyArray<string>),
-              )
+              .$if(createOperationComment(operation), (m, v) => m.doc(v))
               .public()
               .static(!isAngularClient && !plugin.config.instance)
               .$if(
@@ -445,11 +443,11 @@ export const generateClassSdk = ({
       const ctor = $.init((i) =>
         i
           .param('args', (p) =>
-            p.optional(!isClientRequired).type(
+            p.required(isClientRequired).type(
               $.type
                 .object()
                 .prop('client', (p) =>
-                  p.optional(!isClientRequired).type(symbolClient.placeholder),
+                  p.required(isClientRequired).type(symbolClient.placeholder),
                 )
                 .prop('key', (p) => p.optional().type('string')),
             ),
@@ -459,7 +457,7 @@ export const generateClassSdk = ({
             $(symbol.placeholder)
               .attr(registryName)
               .attr('set')
-              .call('this', $('args').attr('key').optional(!isClientRequired)),
+              .call('this', $('args').attr('key').required(isClientRequired)),
           ),
       );
 
diff --git a/packages/openapi-ts/src/plugins/@hey-api/sdk/shared/functions.ts b/packages/openapi-ts/src/plugins/@hey-api/sdk/shared/functions.ts
index 62432b0ad..eefe826ad 100644
--- a/packages/openapi-ts/src/plugins/@hey-api/sdk/shared/functions.ts
+++ b/packages/openapi-ts/src/plugins/@hey-api/sdk/shared/functions.ts
@@ -84,9 +84,7 @@ export const generateFlatSdk = ({
       });
       const node = $.const(symbol.placeholder)
         .export(symbol.exported)
-        .$if(createOperationComment({ operation }), (c, v) =>
-          c.doc(v as ReadonlyArray<string>),
-        )
+        .$if(createOperationComment(operation), (c, v) => c.doc(v))
         .assign(
           $.func()
             .params(...opParameters.parameters)
diff --git a/packages/openapi-ts/src/plugins/@hey-api/sdk/shared/operation.ts b/packages/openapi-ts/src/plugins/@hey-api/sdk/shared/operation.ts
index 3193f3cb0..ed35b7ac7 100644
--- a/packages/openapi-ts/src/plugins/@hey-api/sdk/shared/operation.ts
+++ b/packages/openapi-ts/src/plugins/@hey-api/sdk/shared/operation.ts
@@ -242,7 +242,7 @@ export const operationParameters = ({
           isParametersRequired = true;
         }
         flatParams.prop(parameter.name, (p) =>
-          p.optional(!parameter.isRequired).type(
+          p.required(parameter.isRequired).type(
             pluginTypeScript.api.schemaToType({
               plugin: pluginTypeScript,
               schema: parameter.schema,
@@ -261,7 +261,7 @@ export const operationParameters = ({
 
       result.parameters.push(
         $.param('parameters', (p) =>
-          p.optional(!isParametersRequired).type(flatParams),
+          p.required(isParametersRequired).type(flatParams),
         ),
       );
     }
@@ -269,7 +269,7 @@ export const operationParameters = ({
 
   result.parameters.push(
     $.param('options', (p) =>
-      p.optional(!isRequiredOptions).type(
+      p.required(isRequiredOptions).type(
         operationOptionsType({
           isDataAllowed: plugin.config.paramsStructure === 'grouped',
           operation,
@@ -585,7 +585,7 @@ export const operationStatements = ({
               : operation.body.mediaType,
           ),
         )
-        .spread($('options').attr('headers').optional(!isRequiredOptions));
+        .spread($('options').attr('headers').required(isRequiredOptions));
       if (hasParams) {
         headers.spread($('params').attr('headers'));
       }
@@ -600,9 +600,7 @@ export const operationStatements = ({
     : undefined;
 
   let clientExpression: ReturnType<typeof $.attr | typeof $.binary>;
-  const optionsClient = $('options')
-    .attr('client')
-    .optional(!isRequiredOptions);
+  const optionsClient = $('options').attr('client').required(isRequiredOptions);
   if (plugin.config.instance) {
     clientExpression = optionsClient.coalesce($('this').attr('client'));
   } else if (symbolClient) {
diff --git a/packages/openapi-ts/src/plugins/@hey-api/sdk/shared/typeOptions.ts b/packages/openapi-ts/src/plugins/@hey-api/sdk/shared/typeOptions.ts
index 68cddd647..af87dda6f 100644
--- a/packages/openapi-ts/src/plugins/@hey-api/sdk/shared/typeOptions.ts
+++ b/packages/openapi-ts/src/plugins/@hey-api/sdk/shared/typeOptions.ts
@@ -101,7 +101,7 @@ export const createTypeOptions = ({
                 'individual options. This might be also useful if you want to implement a',
                 'custom client.',
               ])
-              .optional(Boolean(plugin.config.client || plugin.config.instance))
+              .required(!plugin.config.client && !plugin.config.instance)
               .type(symbolClient.placeholder),
           )
           .prop('meta', (p) =>
diff --git a/packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/object.ts b/packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/object.ts
index d2225582e..228da0495 100644
--- a/packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/object.ts
+++ b/packages/openapi-ts/src/plugins/@hey-api/typescript/v1/toAst/object.ts
@@ -36,7 +36,7 @@ export const objectToAst = ({
       p
         .$if(createSchemaComment(property), (p, v) => p.doc(v))
         .readonly(property.accessScope === 'read')
-        .optional(!isRequired)
+        .required(isRequired)
         .type(propertyType),
     );
     indexSchemas.push(property);
diff --git a/packages/openapi-ts/src/plugins/@pinia/colada/mutationOptions.ts b/packages/openapi-ts/src/plugins/@pinia/colada/mutationOptions.ts
index 118d33d63..843544c70 100644
--- a/packages/openapi-ts/src/plugins/@pinia/colada/mutationOptions.ts
+++ b/packages/openapi-ts/src/plugins/@pinia/colada/mutationOptions.ts
@@ -1,9 +1,7 @@
-import type ts from 'typescript';
-
 import type { IR } from '~/ir/types';
 import { buildName } from '~/openApi/shared/utils/name';
 import { createOperationComment } from '~/plugins/shared/utils/operation';
-import { tsc } from '~/tsc';
+import { $ } from '~/ts-dsl';
 
 import { handleMeta } from './meta';
 import type { PiniaColadaPlugin } from './types';
@@ -38,78 +36,41 @@ export const createMutationOptions = ({
 
   const fnOptions = 'fnOptions';
 
-  const awaitSdkExpression = tsc.awaitExpression({
-    expression: tsc.callExpression({
-      functionName: queryFn,
-      parameters: [
-        tsc.objectExpression({
-          multiLine: true,
-          obj: [
-            {
-              spread: 'options',
-            },
-            {
-              spread: fnOptions,
-            },
-            {
-              key: 'throwOnError',
-              value: true,
-            },
-          ],
-        }),
-      ],
-    }),
-  });
+  const awaitSdkFn = $(queryFn)
+    .call(
+      $.object()
+        .pretty()
+        .spread('options')
+        .spread(fnOptions)
+        .prop('throwOnError', $.literal(true)),
+    )
+    .await();
 
-  const statements: Array<ts.Statement> = [];
+  const statements: Array<ReturnType<typeof $.var | typeof $.return>> = [];
 
   if (plugin.getPluginOrThrow('@hey-api/sdk').config.responseStyle === 'data') {
-    statements.push(
-      tsc.returnVariable({
-        expression: awaitSdkExpression,
-      }),
-    );
+    statements.push($.return(awaitSdkFn));
   } else {
     statements.push(
-      tsc.constVariable({
-        destructure: true,
-        expression: awaitSdkExpression,
-        name: 'data',
-      }),
-      tsc.returnVariable({
-        expression: 'data',
-      }),
+      $.const().object('data').assign(awaitSdkFn),
+      $.return('data'),
     );
   }
 
-  const mutationOptionsObj: Array<{ key: string; value: ts.Expression }> = [
-    {
-      key: 'mutation',
-      value: tsc.arrowFunction({
-        async: true,
-        multiLine: true,
-        parameters: [
-          isNuxtClient
-            ? {
-                name: fnOptions,
-                type: `Partial<${strippedTypeData}>`,
-              }
-            : { name: fnOptions },
-        ],
-        statements,
-      }),
-    },
-  ];
-
-  const meta = handleMeta(plugin, operation, 'mutationOptions');
-
-  if (meta) {
-    mutationOptionsObj.push({
-      key: 'meta',
-      value: meta.$render(),
-    });
-  }
-
+  const mutationOpts = $.object()
+    .pretty()
+    .prop(
+      'mutation',
+      $.func()
+        .async()
+        .param(fnOptions, (p) =>
+          p.$if(isNuxtClient, (f) => f.type(`Partial<${strippedTypeData}>`)),
+        )
+        .do(...statements),
+    )
+    .$if(handleMeta(plugin, operation, 'mutationOptions'), (o, v) =>
+      o.prop('meta', v),
+    );
   const symbolMutationOptions = plugin.registerSymbol({
     exported: true,
     name: buildName({
@@ -117,29 +78,18 @@ export const createMutationOptions = ({
       name: operation.id,
     }),
   });
-  const statement = tsc.constVariable({
-    comment: plugin.config.comments
-      ? createOperationComment({ operation })
-      : undefined,
-    exportConst: symbolMutationOptions.exported,
-    expression: tsc.arrowFunction({
-      parameters: [
-        {
-          isRequired: false,
-          name: 'options',
-          type: `Partial<${strippedTypeData}>`,
-        },
-      ],
-      returnType: mutationType,
-      statements: [
-        tsc.returnStatement({
-          expression: tsc.objectExpression({
-            obj: mutationOptionsObj,
-          }),
-        }),
-      ],
-    }),
-    name: symbolMutationOptions.placeholder,
-  });
+  const statement = $.const(symbolMutationOptions.placeholder)
+    .export(symbolMutationOptions.exported)
+    .$if(plugin.config.comments && createOperationComment(operation), (c, v) =>
+      c.doc(v),
+    )
+    .assign(
+      $.func()
+        .param('options', (p) =>
+          p.optional().type(`Partial<${strippedTypeData}>`),
+        )
+        .returns(mutationType)
+        .do($.return(mutationOpts)),
+    );
   plugin.setSymbolValue(symbolMutationOptions, statement);
 };
diff --git a/packages/openapi-ts/src/plugins/@pinia/colada/queryKey.ts b/packages/openapi-ts/src/plugins/@pinia/colada/queryKey.ts
index 522ab8db4..444c95124 100644
--- a/packages/openapi-ts/src/plugins/@pinia/colada/queryKey.ts
+++ b/packages/openapi-ts/src/plugins/@pinia/colada/queryKey.ts
@@ -1,12 +1,11 @@
 import type { Symbol } from '@hey-api/codegen-core';
-import type { Expression } from 'typescript';
 
 import { clientFolderAbsolutePath } from '~/generate/client';
 import { hasOperationDataRequired } from '~/ir/operation';
 import type { IR } from '~/ir/types';
 import { buildName } from '~/openApi/shared/utils/name';
 import { getClientBaseUrlKey } from '~/plugins/@hey-api/client-core/utils';
-import { type Property, tsc } from '~/tsc';
+import { $ } from '~/ts-dsl';
 
 import type { PiniaColadaPlugin } from './types';
 import { useTypeData } from './useType';
@@ -14,8 +13,6 @@ import { getPublicTypeData } from './utils';
 
 const TOptionsType = 'TOptions';
 
-const optionsIdentifier = tsc.identifier({ text: 'options' });
-
 export const createQueryKeyFunction = ({
   plugin,
 }: {
@@ -44,15 +41,9 @@ export const createQueryKeyFunction = ({
     resource: `${plugin.name}._JSONValue`,
   });
 
-  const returnType = tsc.indexedAccessTypeNode({
-    indexType: tsc.literalTypeNode({
-      literal: tsc.ots.number(0),
-    }),
-    objectType: tsc.typeReferenceNode({
-      typeArguments: [tsc.typeReferenceNode({ typeName: TOptionsType })],
-      typeName: symbolQueryKeyType.placeholder,
-    }),
-  });
+  const returnType = $.type(symbolQueryKeyType.placeholder)
+    .generic(TOptionsType)
+    .idx(0);
 
   const baseUrlKey = getClientBaseUrlKey(plugin.context.config);
 
@@ -75,204 +66,56 @@ export const createQueryKeyFunction = ({
     name: 'serializeQueryKeyValue',
   });
 
-  const fn = tsc.constVariable({
-    expression: tsc.arrowFunction({
-      multiLine: true,
-      parameters: [
-        {
-          name: 'id',
-          type: tsc.typeReferenceNode({ typeName: 'string' }),
-        },
-        {
-          isRequired: false,
-          name: 'options',
-          type: tsc.typeReferenceNode({ typeName: TOptionsType }),
-        },
-        {
-          isRequired: false,
-          name: 'tags',
-          type: tsc.typeReferenceNode({ typeName: 'ReadonlyArray<string>' }),
-        },
-      ],
-      returnType: tsc.typeTupleNode({
-        types: [returnType],
-      }),
-      statements: [
-        tsc.constVariable({
-          assertion: returnType,
-          expression: tsc.objectExpression({
-            multiLine: false,
-            obj: [
-              { key: '_id', value: tsc.identifier({ text: 'id' }) },
-              {
-                key: baseUrlKey,
-                value: tsc.identifier({
-                  text: `options?.${baseUrlKey} || (options?.client ?? ${symbolClient?.placeholder}).getConfig().${baseUrlKey}`,
-                }),
-              },
-            ],
-          }),
-          name: 'params',
-          typeName: returnType,
-        }),
-        tsc.ifStatement({
-          expression: tsc.identifier({ text: 'tags' }),
-          thenStatement: tsc.block({
-            statements: [
-              tsc.expressionToStatement({
-                expression: tsc.binaryExpression({
-                  left: tsc.propertyAccessExpression({
-                    expression: 'params',
-                    name: 'tags',
-                  }),
-                  right: tsc.asExpression({
-                    expression: tsc.asExpression({
-                      expression: tsc.identifier({ text: 'tags' }),
-                      type: tsc.keywordTypeNode({ keyword: 'unknown' }),
-                    }),
-                    type: tsc.typeReferenceNode({
-                      typeName: symbolJsonValue.placeholder,
-                    }),
-                  }),
-                }),
-              }),
-            ],
-          }),
-        }),
-        tsc.ifStatement({
-          expression: tsc.binaryExpression({
-            left: tsc.propertyAccessExpression({
-              expression: optionsIdentifier,
-              isOptional: true,
-              name: tsc.identifier({ text: 'body' }),
-            }),
-            operator: '!==',
-            right: 'undefined',
-          }),
-          thenStatement: tsc.block({
-            statements: [
-              tsc.constVariable({
-                expression: tsc.callExpression({
-                  functionName: symbolSerializeQueryValue.placeholder,
-                  parameters: [
-                    tsc.propertyAccessExpression({
-                      expression: 'options',
-                      name: 'body',
-                    }),
-                  ],
-                }),
-                name: 'normalizedBody',
-              }),
-              tsc.ifStatement({
-                expression: tsc.binaryExpression({
-                  left: tsc.identifier({ text: 'normalizedBody' }),
-                  operator: '!==',
-                  right: 'undefined',
-                }),
-                thenStatement: tsc.block({
-                  statements: [
-                    tsc.expressionToStatement({
-                      expression: tsc.binaryExpression({
-                        left: tsc.propertyAccessExpression({
-                          expression: 'params',
-                          name: 'body',
-                        }),
-                        right: tsc.identifier({ text: 'normalizedBody' }),
-                      }),
-                    }),
-                  ],
-                }),
-              }),
-            ],
-          }),
-        }),
-        tsc.ifStatement({
-          expression: tsc.propertyAccessExpression({
-            expression: optionsIdentifier,
-            isOptional: true,
-            name: tsc.identifier({ text: 'path' }),
-          }),
-          thenStatement: tsc.block({
-            statements: [
-              tsc.expressionToStatement({
-                expression: tsc.binaryExpression({
-                  left: tsc.propertyAccessExpression({
-                    expression: 'params',
-                    name: 'path',
-                  }),
-                  right: tsc.propertyAccessExpression({
-                    expression: 'options',
-                    name: 'path',
-                  }),
-                }),
-              }),
-            ],
-          }),
-        }),
-        tsc.ifStatement({
-          expression: tsc.binaryExpression({
-            left: tsc.propertyAccessExpression({
-              expression: optionsIdentifier,
-              isOptional: true,
-              name: tsc.identifier({ text: 'query' }),
-            }),
-            operator: '!==',
-            right: 'undefined',
-          }),
-          thenStatement: tsc.block({
-            statements: [
-              tsc.constVariable({
-                expression: tsc.callExpression({
-                  functionName: symbolSerializeQueryValue.placeholder,
-                  parameters: [
-                    tsc.propertyAccessExpression({
-                      expression: 'options',
-                      name: 'query',
-                    }),
-                  ],
-                }),
-                name: 'normalizedQuery',
-              }),
-              tsc.ifStatement({
-                expression: tsc.binaryExpression({
-                  left: tsc.identifier({ text: 'normalizedQuery' }),
-                  operator: '!==',
-                  right: 'undefined',
-                }),
-                thenStatement: tsc.block({
-                  statements: [
-                    tsc.expressionToStatement({
-                      expression: tsc.binaryExpression({
-                        left: tsc.propertyAccessExpression({
-                          expression: 'params',
-                          name: 'query',
-                        }),
-                        right: tsc.identifier({ text: 'normalizedQuery' }),
-                      }),
-                    }),
-                  ],
-                }),
-              }),
-            ],
-          }),
-        }),
-        tsc.returnStatement({
-          expression: tsc.arrayLiteralExpression({
-            elements: [tsc.identifier({ text: 'params' })],
-          }),
-        }),
-      ],
-      types: [
-        {
-          extends: tsc.typeReferenceNode({
-            typeName: tsc.identifier({ text: symbolOptions.placeholder }),
-          }),
-          name: TOptionsType,
-        },
-      ],
-    }),
-    name: symbolCreateQueryKey.placeholder,
-  });
+  const fn = $.const(symbolCreateQueryKey.placeholder).assign(
+    $.func()
+      .param('id', (p) => p.type('string'))
+      .param('options', (p) => p.optional().type(TOptionsType))
+      .param('tags', (p) => p.optional().type('ReadonlyArray<string>'))
+      .returns($.type.tuple(returnType))
+      .generic(TOptionsType, (g) => g.extends(symbolOptions.placeholder))
+      .do(
+        $.const('params')
+          .type(returnType)
+          .assign(
+            $.object()
+              .prop('_id', 'id')
+              .prop(
+                baseUrlKey,
+                `options?.${baseUrlKey} || (options?.client ?? ${symbolClient?.placeholder}).getConfig().${baseUrlKey}`,
+              )
+              .as(returnType),
+          ),
+        $.if('tags').do(
+          $('params')
+            .attr('tags')
+            .assign($('tags').as('unknown').as(symbolJsonValue.placeholder)),
+        ),
+        $.if($('options').attr('body').optional().neq($.id('undefined'))).do(
+          $.const('normalizedBody').assign(
+            $(symbolSerializeQueryValue.placeholder).call(
+              $('options').attr('body'),
+            ),
+          ),
+          $.if($('normalizedBody').neq($.id('undefined'))).do(
+            $('params').attr('body').assign('normalizedBody'),
+          ),
+        ),
+        $.if($('options').attr('path').optional()).do(
+          $('params').attr('path').assign($('options').attr('path')),
+        ),
+        $.if($('options').attr('query').optional().neq($.id('undefined'))).do(
+          $.const('normalizedQuery').assign(
+            $(symbolSerializeQueryValue.placeholder).call(
+              $('options').attr('query'),
+            ),
+          ),
+          $.if($('normalizedQuery').neq($.id('undefined'))).do(
+            $('params').attr('query').assign('normalizedQuery'),
+          ),
+        ),
+        $.return($.array($('params'))),
+      ),
+  );
   plugin.setSymbolValue(symbolCreateQueryKey, fn);
 };
 
@@ -286,11 +129,9 @@ const createQueryKeyLiteral = ({
   plugin: PiniaColadaPlugin['Instance'];
 }) => {
   const config = plugin.config.queryKeys;
-  let tagsExpression: Expression | undefined;
+  let tagsExpression: ReturnType<typeof $.array> | undefined;
   if (config.tags && operation.tags && operation.tags.length > 0) {
-    tagsExpression = tsc.arrayLiteralExpression({
-      elements: operation.tags.map((tag) => tsc.stringLiteral({ text: tag })),
-    });
+    tagsExpression = $.array(...operation.tags.map((tag) => $.literal(tag)));
   }
 
   const symbolCreateQueryKey = plugin.referenceSymbol({
@@ -298,10 +139,11 @@ const createQueryKeyLiteral = ({
     resource: 'createQueryKey',
     tool: plugin.name,
   });
-  const createQueryKeyCallExpression = tsc.callExpression({
-    functionName: symbolCreateQueryKey.placeholder,
-    parameters: [tsc.ots.string(id), 'options', tagsExpression],
-  });
+  const createQueryKeyCallExpression = $(symbolCreateQueryKey.placeholder).call(
+    $.literal(id),
+    'options',
+    tagsExpression,
+  );
   return createQueryKeyCallExpression;
 };
 
@@ -315,30 +157,6 @@ export const createQueryKeyType = ({
     resource: `${plugin.name}._JSONValue`,
   });
 
-  const properties: Array<Property> = [
-    { name: '_id', type: tsc.keywordTypeNode({ keyword: 'string' }) },
-    {
-      isRequired: false,
-      name: getClientBaseUrlKey(plugin.context.config),
-      type: tsc.typeReferenceNode({ typeName: symbolJsonValue.placeholder }),
-    },
-    {
-      isRequired: false,
-      name: 'body',
-      type: tsc.typeReferenceNode({ typeName: symbolJsonValue.placeholder }),
-    },
-    {
-      isRequired: false,
-      name: 'query',
-      type: tsc.typeReferenceNode({ typeName: symbolJsonValue.placeholder }),
-    },
-    {
-      isRequired: false,
-      name: 'tags',
-      type: tsc.typeReferenceNode({ typeName: symbolJsonValue.placeholder }),
-    },
-  ];
-
   const symbolOptions = plugin.referenceSymbol({
     category: 'type',
     resource: 'client-options',
@@ -354,33 +172,30 @@ export const createQueryKeyType = ({
     },
     name: 'QueryKey',
   });
-  const queryKeyType = tsc.typeAliasDeclaration({
-    exportType: symbolQueryKeyType.exported,
-    name: symbolQueryKeyType.placeholder,
-    type: tsc.typeTupleNode({
-      types: [
-        tsc.typeIntersectionNode({
-          types: [
-            tsc.typeReferenceNode({
-              typeName: `Pick<${TOptionsType}, 'path'>`,
-            }),
-            tsc.typeInterfaceNode({
-              properties,
-              useLegacyResolution: true,
-            }),
-          ],
-        }),
-      ],
-    }),
-    typeParameters: [
-      {
-        extends: tsc.typeReferenceNode({
-          typeName: tsc.identifier({ text: symbolOptions.placeholder }),
-        }),
-        name: TOptionsType,
-      },
-    ],
-  });
+  const queryKeyType = $.type
+    .alias(symbolQueryKeyType.placeholder)
+    .export(symbolQueryKeyType.exported)
+    .generic(TOptionsType, (g) => g.extends($.type(symbolOptions.placeholder)))
+    .type(
+      $.type.tuple(
+        $.type.and(
+          $.type(`Pick<${TOptionsType}, 'path'>`),
+          $.type
+            .object()
+            .prop('_id', (p) => p.type('string'))
+            .prop(getClientBaseUrlKey(plugin.context.config), (p) =>
+              p.optional().type(symbolJsonValue.placeholder),
+            )
+            .prop('body', (p) => p.optional().type(symbolJsonValue.placeholder))
+            .prop('query', (p) =>
+              p.optional().type(symbolJsonValue.placeholder),
+            )
+            .prop('tags', (p) =>
+              p.optional().type(symbolJsonValue.placeholder),
+            ),
+        ),
+      ),
+    );
   plugin.setSymbolValue(symbolQueryKeyType, queryKeyType);
 };
 
@@ -395,23 +210,22 @@ export const queryKeyStatement = ({
 }) => {
   const typeData = useTypeData({ operation, plugin });
   const { strippedTypeData } = getPublicTypeData({ plugin, typeData });
-  const statement = tsc.constVariable({
-    exportConst: symbol.exported,
-    expression: tsc.arrowFunction({
-      parameters: [
-        {
-          isRequired: hasOperationDataRequired(operation),
-          name: 'options',
-          type: strippedTypeData,
-        },
-      ],
-      statements: createQueryKeyLiteral({
-        id: operation.id,
-        operation,
-        plugin,
-      }),
-    }),
-    name: symbol.placeholder,
-  });
+  const statement = $.const(symbol.placeholder)
+    .export(symbol.exported)
+    .assign(
+      $.func()
+        .param('options', (p) =>
+          p
+            .required(hasOperationDataRequired(operation))
+            .type(strippedTypeData),
+        )
+        .do(
+          createQueryKeyLiteral({
+            id: operation.id,
+            operation,
+            plugin,
+          }).return(),
+        ),
+    );
   return statement;
 };
diff --git a/packages/openapi-ts/src/plugins/@pinia/colada/queryOptions.ts b/packages/openapi-ts/src/plugins/@pinia/colada/queryOptions.ts
index ddc51c863..54d553926 100644
--- a/packages/openapi-ts/src/plugins/@pinia/colada/queryOptions.ts
+++ b/packages/openapi-ts/src/plugins/@pinia/colada/queryOptions.ts
@@ -1,5 +1,3 @@
-import type ts from 'typescript';
-
 import type { IR } from '~/ir/types';
 import { buildName } from '~/openApi/shared/utils/name';
 import {
@@ -7,7 +5,7 @@ import {
   hasOperationSse,
   isOperationOptionsRequired,
 } from '~/plugins/shared/utils/operation';
-import { tsc } from '~/tsc';
+import { $ } from '~/ts-dsl';
 
 import { handleMeta } from './meta';
 import {
@@ -50,7 +48,7 @@ export const createQueryOptions = ({
     createQueryKeyFunction({ plugin });
   }
 
-  let keyExpression: ts.Expression;
+  let keyExpression: ReturnType<typeof $.call>;
   if (plugin.config.queryKeys.enabled) {
     const symbolQueryKey = plugin.registerSymbol({
       exported: true,
@@ -65,10 +63,7 @@ export const createQueryOptions = ({
       symbol: symbolQueryKey,
     });
     plugin.setSymbolValue(symbolQueryKey, node);
-    keyExpression = tsc.callExpression({
-      functionName: symbolQueryKey.placeholder,
-      parameters: [optionsParamName],
-    });
+    keyExpression = $(symbolQueryKey.placeholder).call(optionsParamName);
   } else {
     const symbolCreateQueryKey = plugin.referenceSymbol({
       category: 'utility',
@@ -76,20 +71,19 @@ export const createQueryOptions = ({
       tool: plugin.name,
     });
     // Optionally include tags when configured
-    let tagsExpr: ts.Expression | undefined;
+    let tagsExpr: ReturnType<typeof $.array> | undefined;
     if (
       plugin.config.queryKeys.tags &&
       operation.tags &&
       operation.tags.length > 0
     ) {
-      tagsExpr = tsc.arrayLiteralExpression({
-        elements: operation.tags.map((t) => tsc.stringLiteral({ text: t })),
-      });
+      tagsExpr = $.array(...operation.tags.map((t) => $.literal(t)));
     }
-    keyExpression = tsc.callExpression({
-      functionName: symbolCreateQueryKey.placeholder,
-      parameters: [tsc.ots.string(operation.id), optionsParamName, tagsExpr],
-    });
+    keyExpression = $(symbolCreateQueryKey.placeholder).call(
+      $.literal(operation.id),
+      optionsParamName,
+      tagsExpr,
+    );
   }
 
   const typeData = useTypeData({ operation, plugin });
@@ -97,65 +91,38 @@ export const createQueryOptions = ({
     plugin,
     typeData,
   });
-  const awaitSdkExpression = tsc.awaitExpression({
-    expression: tsc.callExpression({
-      functionName: queryFn,
-      parameters: [
-        tsc.objectExpression({
-          multiLine: true,
-          obj: [
-            { spread: optionsParamName },
-            { spread: fnOptions },
-            { key: 'throwOnError', value: true },
-          ],
-        }),
-      ],
-    }),
-  });
+  const awaitSdkFn = $(queryFn)
+    .call(
+      $.object()
+        .spread(optionsParamName)
+        .spread(fnOptions)
+        .prop('throwOnError', $.literal(true)),
+    )
+    .await();
 
-  const statements: Array<ts.Statement> = [];
+  const statements: Array<ReturnType<typeof $.return | typeof $.const>> = [];
   if (plugin.getPluginOrThrow('@hey-api/sdk').config.responseStyle === 'data') {
-    statements.push(
-      tsc.returnVariable({
-        expression: awaitSdkExpression,
-      }),
-    );
+    statements.push($.return(awaitSdkFn));
   } else {
     statements.push(
-      tsc.constVariable({
-        destructure: true,
-        expression: awaitSdkExpression,
-        name: 'data',
-      }),
-      tsc.returnVariable({
-        expression: 'data',
-      }),
+      $.const().object('data').assign(awaitSdkFn),
+      $.return('data'),
     );
   }
 
-  const queryOptionsObj: Array<{ key: string; value: ts.Expression }> = [
-    {
-      key: 'key',
-      value: keyExpression,
-    },
-    {
-      key: 'query',
-      value: tsc.arrowFunction({
-        async: true,
-        multiLine: true,
-        parameters: [{ name: fnOptions }],
-        statements,
-      }),
-    },
-  ];
-
-  const meta = handleMeta(plugin, operation, 'queryOptions');
-  if (meta) {
-    queryOptionsObj.push({
-      key: 'meta',
-      value: meta.$render(),
-    });
-  }
+  const queryOpts = $.object()
+    .pretty()
+    .prop('key', keyExpression)
+    .prop(
+      'query',
+      $.func()
+        .async()
+        .param(fnOptions)
+        .do(...statements),
+    )
+    .$if(handleMeta(plugin, operation, 'queryOptions'), (o, v) =>
+      o.prop('meta', v),
+    );
 
   const symbolQueryOptionsFn = plugin.registerSymbol({
     exported: true,
@@ -175,27 +142,19 @@ export const createQueryOptions = ({
     category: 'external',
     resource: `${plugin.name}.defineQueryOptions`,
   });
-  const statement = tsc.constVariable({
-    comment: plugin.config.comments
-      ? createOperationComment({ operation })
-      : undefined,
-    exportConst: symbolQueryOptionsFn.exported,
-    expression: tsc.callExpression({
-      functionName: symbolDefineQueryOptions.placeholder,
-      parameters: [
-        tsc.arrowFunction({
-          parameters: [
-            {
-              isRequired: isRequiredOptions,
-              name: optionsParamName,
-              type: strippedTypeData,
-            },
-          ],
-          statements: tsc.objectExpression({ obj: queryOptionsObj }),
-        }),
-      ],
-    }),
-    name: symbolQueryOptionsFn.placeholder,
-  });
+  const statement = $.const(symbolQueryOptionsFn.placeholder)
+    .export(symbolQueryOptionsFn.exported)
+    .$if(plugin.config.comments && createOperationComment(operation), (c, v) =>
+      c.doc(v),
+    )
+    .assign(
+      $(symbolDefineQueryOptions.placeholder).call(
+        $.func()
+          .param(optionsParamName, (p) =>
+            p.required(isRequiredOptions).type(strippedTypeData),
+          )
+          .do($.return(queryOpts)),
+      ),
+    );
   plugin.setSymbolValue(symbolQueryOptionsFn, statement);
 };
diff --git a/packages/openapi-ts/src/plugins/@tanstack/query-core/queryKey.ts b/packages/openapi-ts/src/plugins/@tanstack/query-core/queryKey.ts
index 333bfddf4..f4aaa51ff 100644
--- a/packages/openapi-ts/src/plugins/@tanstack/query-core/queryKey.ts
+++ b/packages/openapi-ts/src/plugins/@tanstack/query-core/queryKey.ts
@@ -181,7 +181,7 @@ export const queryKeyStatement = ({
     .assign(
       $.func()
         .param('options', (p) =>
-          p.optional(!hasOperationDataRequired(operation)).type(typeData),
+          p.required(hasOperationDataRequired(operation)).type(typeData),
         )
         .$if(isInfinite && typeQueryKey, (f, v) => f.returns(v))
         .do(
diff --git a/packages/openapi-ts/src/plugins/@tanstack/query-core/v5/infiniteQueryOptions.ts b/packages/openapi-ts/src/plugins/@tanstack/query-core/v5/infiniteQueryOptions.ts
index b197d0a3f..e958e3b76 100644
--- a/packages/openapi-ts/src/plugins/@tanstack/query-core/v5/infiniteQueryOptions.ts
+++ b/packages/openapi-ts/src/plugins/@tanstack/query-core/v5/infiniteQueryOptions.ts
@@ -239,13 +239,12 @@ export const createInfiniteQueryOptions = ({
   });
   const statement = $.const(symbolInfiniteQueryOptionsFn.placeholder)
     .export(symbolInfiniteQueryOptionsFn.exported)
-    .$if(
-      plugin.config.comments && createOperationComment({ operation }),
-      (c, v) => c.doc(v as ReadonlyArray<string>),
+    .$if(plugin.config.comments && createOperationComment(operation), (c, v) =>
+      c.doc(v),
     )
     .assign(
       $.func()
-        .param('options', (p) => p.optional(!isRequiredOptions).type(typeData))
+        .param('options', (p) => p.required(isRequiredOptions).type(typeData))
         .do(
           $.return(
             $(symbolInfiniteQueryOptions.placeholder)
diff --git a/packages/openapi-ts/src/plugins/@tanstack/query-core/v5/mutationOptions.ts b/packages/openapi-ts/src/plugins/@tanstack/query-core/v5/mutationOptions.ts
index 67c9971f3..3dc0fbdd0 100644
--- a/packages/openapi-ts/src/plugins/@tanstack/query-core/v5/mutationOptions.ts
+++ b/packages/openapi-ts/src/plugins/@tanstack/query-core/v5/mutationOptions.ts
@@ -59,9 +59,8 @@ export const createMutationOptions = ({
   });
   const statement = $.const(symbolMutationOptions.placeholder)
     .export(symbolMutationOptions.exported)
-    .$if(
-      plugin.config.comments && createOperationComment({ operation }),
-      (c, v) => c.doc(v as ReadonlyArray<string>),
+    .$if(plugin.config.comments && createOperationComment(operation), (c, v) =>
+      c.doc(v),
     )
     .assign(
       $.func()
diff --git a/packages/openapi-ts/src/plugins/@tanstack/query-core/v5/queryOptions.ts b/packages/openapi-ts/src/plugins/@tanstack/query-core/v5/queryOptions.ts
index 23007a1ef..72c678152 100644
--- a/packages/openapi-ts/src/plugins/@tanstack/query-core/v5/queryOptions.ts
+++ b/packages/openapi-ts/src/plugins/@tanstack/query-core/v5/queryOptions.ts
@@ -124,14 +124,13 @@ export const createQueryOptions = ({
   // TODO: AxiosError<PutSubmissionMetaError>
   const statement = $.const(symbolQueryOptionsFn.placeholder)
     .export(symbolQueryOptionsFn.exported)
-    .$if(
-      plugin.config.comments && createOperationComment({ operation }),
-      (c, v) => c.doc(v as ReadonlyArray<string>),
+    .$if(plugin.config.comments && createOperationComment(operation), (c, v) =>
+      c.doc(v),
     )
     .assign(
       $.func()
         .param(optionsParamName, (p) =>
-          p.optional(!isRequiredOptions).type(typeData),
+          p.required(isRequiredOptions).type(typeData),
         )
         .do(
           $(symbolQueryOptions.placeholder)
diff --git a/packages/openapi-ts/src/plugins/@tanstack/query-core/v5/useQuery.ts b/packages/openapi-ts/src/plugins/@tanstack/query-core/v5/useQuery.ts
index f6594dc11..dc5a22a10 100644
--- a/packages/openapi-ts/src/plugins/@tanstack/query-core/v5/useQuery.ts
+++ b/packages/openapi-ts/src/plugins/@tanstack/query-core/v5/useQuery.ts
@@ -55,14 +55,13 @@ export const createUseQuery = ({
   });
   const statement = $.const(symbolUseQueryFn.placeholder)
     .export(symbolUseQueryFn.exported)
-    .$if(
-      plugin.config.comments && createOperationComment({ operation }),
-      (c, v) => c.doc(v as ReadonlyArray<string>),
+    .$if(plugin.config.comments && createOperationComment(operation), (c, v) =>
+      c.doc(v),
     )
     .assign(
       $.func()
         .param(optionsParamName, (p) =>
-          p.optional(!isRequiredOptions).type(typeData),
+          p.required(isRequiredOptions).type(typeData),
         )
         .do(
           $(symbolUseQuery.placeholder)
diff --git a/packages/openapi-ts/src/plugins/fastify/plugin.ts b/packages/openapi-ts/src/plugins/fastify/plugin.ts
index bfb810cc3..5185de5ad 100644
--- a/packages/openapi-ts/src/plugins/fastify/plugin.ts
+++ b/packages/openapi-ts/src/plugins/fastify/plugin.ts
@@ -25,8 +25,8 @@ const operationToRouteHandler = ({
     if (operation.body) {
       type.prop('Body', (p) =>
         p
-          .optional(!operation.body!.required)
-          .type(`${symbolDataType.placeholder}['body']`),
+          .required(operation.body!.required)
+          .type($.type(symbolDataType.placeholder).idx($.type.literal('body'))),
       );
     }
 
@@ -34,30 +34,36 @@ const operationToRouteHandler = ({
       if (operation.parameters.header) {
         type.prop('Headers', (p) =>
           p
-            .optional(
-              !hasParameterGroupObjectRequired(operation.parameters!.header),
+            .required(
+              hasParameterGroupObjectRequired(operation.parameters!.header),
             )
-            .type(`${symbolDataType.placeholder}['headers']`),
+            .type(
+              $.type(symbolDataType.placeholder).idx($.type.literal('headers')),
+            ),
         );
       }
 
       if (operation.parameters.path) {
         type.prop('Params', (p) =>
           p
-            .optional(
-              !hasParameterGroupObjectRequired(operation.parameters!.path),
+            .required(
+              hasParameterGroupObjectRequired(operation.parameters!.path),
             )
-            .type(`${symbolDataType.placeholder}['path']`),
+            .type(
+              $.type(symbolDataType.placeholder).idx($.type.literal('path')),
+            ),
         );
       }
 
       if (operation.parameters.query) {
         type.prop('Querystring', (p) =>
           p
-            .optional(
-              !hasParameterGroupObjectRequired(operation.parameters!.query),
+            .required(
+              hasParameterGroupObjectRequired(operation.parameters!.query),
             )
-            .type(`${symbolDataType.placeholder}['query']`),
+            .type(
+              $.type(symbolDataType.placeholder).idx($.type.literal('query')),
+            ),
         );
       }
     }
diff --git a/packages/openapi-ts/src/plugins/shared/utils/operation.ts b/packages/openapi-ts/src/plugins/shared/utils/operation.ts
index e1675484e..1f3199c73 100644
--- a/packages/openapi-ts/src/plugins/shared/utils/operation.ts
+++ b/packages/openapi-ts/src/plugins/shared/utils/operation.ts
@@ -2,14 +2,11 @@ import type { Context } from '~/ir/context';
 import { hasOperationDataRequired } from '~/ir/operation';
 import type { IR } from '~/ir/types';
 import { getClientPlugin } from '~/plugins/@hey-api/client-core/utils';
-import type { Comments } from '~/tsc';
 import { escapeComment } from '~/utils/escape';
 
-export const createOperationComment = ({
-  operation,
-}: {
-  operation: IR.OperationObject;
-}): Comments | undefined => {
+export const createOperationComment = (
+  operation: IR.OperationObject,
+): ReadonlyArray<string> | undefined => {
   const comments: Array<string> = [];
 
   if (operation.summary) {
@@ -32,11 +29,7 @@ export const createOperationComment = ({
     comments.push('@deprecated');
   }
 
-  if (!comments.length) {
-    return;
-  }
-
-  return comments;
+  return comments.length ? comments : undefined;
 };
 
 export const isOperationOptionsRequired = ({
diff --git a/packages/openapi-ts/src/plugins/swr/v2/useSwr.ts b/packages/openapi-ts/src/plugins/swr/v2/useSwr.ts
index 94f9ec7c9..ee528a80b 100644
--- a/packages/openapi-ts/src/plugins/swr/v2/useSwr.ts
+++ b/packages/openapi-ts/src/plugins/swr/v2/useSwr.ts
@@ -50,9 +50,8 @@ export const createUseSwr = ({
 
   const statement = $.const(symbolUseQueryFn.placeholder)
     .export(symbolUseQueryFn.exported)
-    .$if(
-      plugin.config.comments && createOperationComment({ operation }),
-      (c, v) => c.doc(v as ReadonlyArray<string>),
+    .$if(plugin.config.comments && createOperationComment(operation), (c, v) =>
+      c.doc(v),
     )
     .assign(
       $.func().do(
diff --git a/packages/openapi-ts/src/ts-dsl/mixins/optional.ts b/packages/openapi-ts/src/ts-dsl/mixins/optional.ts
index 155b5171c..257790eb4 100644
--- a/packages/openapi-ts/src/ts-dsl/mixins/optional.ts
+++ b/packages/openapi-ts/src/ts-dsl/mixins/optional.ts
@@ -1,8 +1,15 @@
 export class OptionalMixin {
   protected _optional?: boolean;
 
-  optional<T extends this>(this: T, condition: boolean = true): T {
-    this._optional = condition;
+  /** Marks the node as optional when the condition is true. */
+  optional<T extends this>(this: T, condition?: boolean): T {
+    this._optional = arguments.length === 0 ? true : Boolean(condition);
+    return this;
+  }
+
+  /** Marks the node as required when the condition is true. */
+  required<T extends this>(this: T, condition?: boolean): T {
+    this._optional = arguments.length === 0 ? false : !condition;
     return this;
   }
 }