diff --git a/analysis_options.yaml b/analysis_options.yaml
index f6177cd..ba5e0a9 100644
--- a/analysis_options.yaml
+++ b/analysis_options.yaml
@@ -134,6 +134,7 @@
     - leading_newlines_in_multiline_strings
     - library_names
     - library_prefixes
+    - library_private_types_in_public_api
     # - lines_longer_than_80_chars # not required by flutter style
     - list_remove_unrelated_type
     # - literal_only_boolean_expressions # too many false positives: https://github.com/dart-lang/sdk/issues/34181
@@ -197,7 +198,7 @@
     - recursive_getters
     # - sized_box_for_whitespace # not yet tested
     - slash_for_doc_comments
-    # - sort_child_properties_last # not yet tested
+    - sort_child_properties_last
     - sort_constructors_first
     - sort_unnamed_constructors_first
     - test_types_in_equals
@@ -229,7 +230,7 @@
     - use_full_hex_values_for_flutter_colors
     # - use_function_type_syntax_for_parameters # not yet tested
     - use_is_even_rather_than_modulo
-    # - use_key_in_widget_constructors # not yet tested
+    - use_key_in_widget_constructors
     - use_late_for_private_fields_and_variables
     - use_raw_strings
     - use_rethrow_when_possible
diff --git a/packages/camera/camera/CHANGELOG.md b/packages/camera/camera/CHANGELOG.md
index 4d7e9bb..bf0ccf8 100644
--- a/packages/camera/camera/CHANGELOG.md
+++ b/packages/camera/camera/CHANGELOG.md
@@ -1,6 +1,8 @@
-## NEXT
+## 0.9.4+22
 
 * Removes unnecessary imports.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 0.9.4+21
 
diff --git a/packages/camera/camera/README.md b/packages/camera/camera/README.md
index 97b16d2..0bcaeae 100644
--- a/packages/camera/camera/README.md
+++ b/packages/camera/camera/README.md
@@ -89,18 +89,22 @@
 import 'package:camera/camera.dart';
 import 'package:flutter/material.dart';
 
-late List<CameraDescription> cameras;
+late List<CameraDescription> _cameras;
 
 Future<void> main() async {
   WidgetsFlutterBinding.ensureInitialized();
 
-  cameras = await availableCameras();
-  runApp(CameraApp());
+  _cameras = await availableCameras();
+  runApp(const CameraApp());
 }
 
+/// CameraApp is the Main Application.
 class CameraApp extends StatefulWidget {
+  /// Default Constructor
+  const CameraApp({Key? key}) : super(key: key);
+
   @override
-  _CameraAppState createState() => _CameraAppState();
+  State<CameraApp> createState() => _CameraAppState();
 }
 
 class _CameraAppState extends State<CameraApp> {
@@ -109,7 +113,7 @@
   @override
   void initState() {
     super.initState();
-    controller = CameraController(cameras[0], ResolutionPreset.max);
+    controller = CameraController(_cameras[0], ResolutionPreset.max);
     controller.initialize().then((_) {
       if (!mounted) {
         return;
diff --git a/packages/camera/camera/example/lib/main.dart b/packages/camera/camera/example/lib/main.dart
index aabbe24..a645326 100644
--- a/packages/camera/camera/example/lib/main.dart
+++ b/packages/camera/camera/example/lib/main.dart
@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// ignore_for_file: public_member_api_docs
-
 import 'dart:async';
 import 'dart:io';
 
@@ -13,9 +11,13 @@
 import 'package:flutter/scheduler.dart';
 import 'package:video_player/video_player.dart';
 
+/// Camera example home widget.
 class CameraExampleHome extends StatefulWidget {
+  /// Default Constructor
+  const CameraExampleHome({Key? key}) : super(key: key);
+
   @override
-  _CameraExampleHomeState createState() {
+  State<CameraExampleHome> createState() {
     return _CameraExampleHomeState();
   }
 }
@@ -34,7 +36,7 @@
   }
 }
 
-void logError(String code, String? message) {
+void _logError(String code, String? message) {
   if (message != null) {
     print('Error: $code\nError Message: $message');
   } else {
@@ -134,12 +136,6 @@
         children: <Widget>[
           Expanded(
             child: Container(
-              child: Padding(
-                padding: const EdgeInsets.all(1.0),
-                child: Center(
-                  child: _cameraPreviewWidget(),
-                ),
-              ),
               decoration: BoxDecoration(
                 color: Colors.black,
                 border: Border.all(
@@ -150,6 +146,12 @@
                   width: 3.0,
                 ),
               ),
+              child: Padding(
+                padding: const EdgeInsets.all(1.0),
+                child: Center(
+                  child: _cameraPreviewWidget(),
+                ),
+              ),
             ),
           ),
           _captureControlRowWidget(),
@@ -233,6 +235,8 @@
               Container()
             else
               SizedBox(
+                width: 64.0,
+                height: 64.0,
                 child: (localVideoController == null)
                     ? (
                         // The captured image on the web contains a network-accessible URL
@@ -243,6 +247,8 @@
                             ? Image.network(imageFile!.path)
                             : Image.file(File(imageFile!.path)))
                     : Container(
+                        decoration: BoxDecoration(
+                            border: Border.all(color: Colors.pink)),
                         child: Center(
                           child: AspectRatio(
                               aspectRatio:
@@ -251,11 +257,7 @@
                                       : 1.0,
                               child: VideoPlayer(localVideoController)),
                         ),
-                        decoration: BoxDecoration(
-                            border: Border.all(color: Colors.pink)),
                       ),
-                width: 64.0,
-                height: 64.0,
               ),
           ],
         ),
@@ -394,7 +396,6 @@
                 mainAxisSize: MainAxisSize.max,
                 children: <Widget>[
                   TextButton(
-                    child: const Text('AUTO'),
                     style: styleAuto,
                     onPressed: controller != null
                         ? () =>
@@ -406,21 +407,22 @@
                         showInSnackBar('Resetting exposure point');
                       }
                     },
+                    child: const Text('AUTO'),
                   ),
                   TextButton(
-                    child: const Text('LOCKED'),
                     style: styleLocked,
                     onPressed: controller != null
                         ? () =>
                             onSetExposureModeButtonPressed(ExposureMode.locked)
                         : null,
+                    child: const Text('LOCKED'),
                   ),
                   TextButton(
-                    child: const Text('RESET OFFSET'),
                     style: styleLocked,
                     onPressed: controller != null
                         ? () => controller!.setExposureOffset(0.0)
                         : null,
+                    child: const Text('RESET OFFSET'),
                   ),
                 ],
               ),
@@ -479,7 +481,6 @@
                 mainAxisSize: MainAxisSize.max,
                 children: <Widget>[
                   TextButton(
-                    child: const Text('AUTO'),
                     style: styleAuto,
                     onPressed: controller != null
                         ? () => onSetFocusModeButtonPressed(FocusMode.auto)
@@ -490,13 +491,14 @@
                       }
                       showInSnackBar('Resetting focus point');
                     },
+                    child: const Text('AUTO'),
                   ),
                   TextButton(
-                    child: const Text('LOCKED'),
                     style: styleLocked,
                     onPressed: controller != null
                         ? () => onSetFocusModeButtonPressed(FocusMode.locked)
                         : null,
+                    child: const Text('LOCKED'),
                   ),
                 ],
               ),
@@ -582,13 +584,13 @@
       onNewCameraSelected(description);
     };
 
-    if (cameras.isEmpty) {
+    if (_cameras.isEmpty) {
       _ambiguate(SchedulerBinding.instance)?.addPostFrameCallback((_) async {
         showInSnackBar('No camera found.');
       });
       return const Text('None');
     } else {
-      for (final CameraDescription cameraDescription in cameras) {
+      for (final CameraDescription cameraDescription in _cameras) {
         toggles.add(
           SizedBox(
             width: 90.0,
@@ -1014,31 +1016,35 @@
   }
 
   void _showCameraException(CameraException e) {
-    logError(e.code, e.description);
+    _logError(e.code, e.description);
     showInSnackBar('Error: ${e.code}\n${e.description}');
   }
 }
 
+/// CameraApp is the Main Application.
 class CameraApp extends StatelessWidget {
+  /// Default Constructor
+  const CameraApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
-    return MaterialApp(
+    return const MaterialApp(
       home: CameraExampleHome(),
     );
   }
 }
 
-List<CameraDescription> cameras = <CameraDescription>[];
+List<CameraDescription> _cameras = <CameraDescription>[];
 
 Future<void> main() async {
   // Fetch the available cameras before initializing the app.
   try {
     WidgetsFlutterBinding.ensureInitialized();
-    cameras = await availableCameras();
+    _cameras = await availableCameras();
   } on CameraException catch (e) {
-    logError(e.code, e.description);
+    _logError(e.code, e.description);
   }
-  runApp(CameraApp());
+  runApp(const CameraApp());
 }
 
 /// This allows a value of type T or T? to be treated as a value of type T?.
diff --git a/packages/camera/camera/example/lib/readme_full_example.dart b/packages/camera/camera/example/lib/readme_full_example.dart
index b25e637..a310fd9 100644
--- a/packages/camera/camera/example/lib/readme_full_example.dart
+++ b/packages/camera/camera/example/lib/readme_full_example.dart
@@ -2,24 +2,26 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// ignore_for_file: public_member_api_docs
-
 // #docregion FullAppExample
 import 'package:camera/camera.dart';
 import 'package:flutter/material.dart';
 
-late List<CameraDescription> cameras;
+late List<CameraDescription> _cameras;
 
 Future<void> main() async {
   WidgetsFlutterBinding.ensureInitialized();
 
-  cameras = await availableCameras();
-  runApp(CameraApp());
+  _cameras = await availableCameras();
+  runApp(const CameraApp());
 }
 
+/// CameraApp is the Main Application.
 class CameraApp extends StatefulWidget {
+  /// Default Constructor
+  const CameraApp({Key? key}) : super(key: key);
+
   @override
-  _CameraAppState createState() => _CameraAppState();
+  State<CameraApp> createState() => _CameraAppState();
 }
 
 class _CameraAppState extends State<CameraApp> {
@@ -28,7 +30,7 @@
   @override
   void initState() {
     super.initState();
-    controller = CameraController(cameras[0], ResolutionPreset.max);
+    controller = CameraController(_cameras[0], ResolutionPreset.max);
     controller.initialize().then((_) {
       if (!mounted) {
         return;
diff --git a/packages/camera/camera/example/test/main_test.dart b/packages/camera/camera/example/test/main_test.dart
index 9a5fcdf..6e909ef 100644
--- a/packages/camera/camera/example/test/main_test.dart
+++ b/packages/camera/camera/example/test/main_test.dart
@@ -9,7 +9,7 @@
 void main() {
   testWidgets('Test snackbar', (WidgetTester tester) async {
     WidgetsFlutterBinding.ensureInitialized();
-    await tester.pumpWidget(CameraApp());
+    await tester.pumpWidget(const CameraApp());
     await tester.pumpAndSettle();
     expect(find.byType(SnackBar), findsOneWidget);
   });
diff --git a/packages/camera/camera/lib/src/camera_preview.dart b/packages/camera/camera/lib/src/camera_preview.dart
index a9b3f21..94ffca6 100644
--- a/packages/camera/camera/lib/src/camera_preview.dart
+++ b/packages/camera/camera/lib/src/camera_preview.dart
@@ -10,7 +10,8 @@
 /// A widget showing a live camera preview.
 class CameraPreview extends StatelessWidget {
   /// Creates a preview widget for the given camera controller.
-  const CameraPreview(this.controller, {this.child});
+  const CameraPreview(this.controller, {Key? key, this.child})
+      : super(key: key);
 
   /// The controller for the camera that the preview is shown for.
   final CameraController controller;
diff --git a/packages/camera/camera/pubspec.yaml b/packages/camera/camera/pubspec.yaml
index f627770..fde6663 100644
--- a/packages/camera/camera/pubspec.yaml
+++ b/packages/camera/camera/pubspec.yaml
@@ -4,7 +4,7 @@
   Dart.
 repository: https://github.com/flutter/plugins/tree/main/packages/camera/camera
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+camera%22
-version: 0.9.4+21
+version: 0.9.4+22
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/camera/camera_web/CHANGELOG.md b/packages/camera/camera_web/CHANGELOG.md
index 852e4a0..7a24e12 100644
--- a/packages/camera/camera_web/CHANGELOG.md
+++ b/packages/camera/camera_web/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 0.2.1+5
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
+
 ## 0.2.1+4
 
 * Migrates from `ui.hash*` to `Object.hash*`.
diff --git a/packages/camera/camera_web/example/lib/main.dart b/packages/camera/camera_web/example/lib/main.dart
index ab04ce2..670891f 100644
--- a/packages/camera/camera_web/example/lib/main.dart
+++ b/packages/camera/camera_web/example/lib/main.dart
@@ -4,10 +4,13 @@
 
 import 'package:flutter/material.dart';
 
-void main() => runApp(MyApp());
+void main() => runApp(const MyApp());
 
 /// App for testing
 class MyApp extends StatelessWidget {
+  /// Default Constructor
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     return const Directionality(
diff --git a/packages/camera/camera_web/pubspec.yaml b/packages/camera/camera_web/pubspec.yaml
index 2d1a450..8bef974 100644
--- a/packages/camera/camera_web/pubspec.yaml
+++ b/packages/camera/camera_web/pubspec.yaml
@@ -2,7 +2,7 @@
 description: A Flutter plugin for getting information about and controlling the camera on Web.
 repository: https://github.com/flutter/plugins/tree/main/packages/camera/camera_web
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+camera%22
-version: 0.2.1+4
+version: 0.2.1+5
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/camera/camera_windows/CHANGELOG.md b/packages/camera/camera_windows/CHANGELOG.md
index b1383dc..0f3bf44 100644
--- a/packages/camera/camera_windows/CHANGELOG.md
+++ b/packages/camera/camera_windows/CHANGELOG.md
@@ -1,6 +1,8 @@
-## NEXT
+## 0.1.0+1
 
 * Removes unnecessary imports.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 0.1.0
 
diff --git a/packages/camera/camera_windows/example/lib/main.dart b/packages/camera/camera_windows/example/lib/main.dart
index b73e00c..5758b0f 100644
--- a/packages/camera/camera_windows/example/lib/main.dart
+++ b/packages/camera/camera_windows/example/lib/main.dart
@@ -9,11 +9,14 @@
 import 'package:flutter/services.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 /// Example app for Camera Windows plugin.
 class MyApp extends StatefulWidget {
+  /// Default Constructor
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   State<MyApp> createState() => _MyAppState();
 }
diff --git a/packages/camera/camera_windows/pubspec.yaml b/packages/camera/camera_windows/pubspec.yaml
index 1081c3d..fe655b0 100644
--- a/packages/camera/camera_windows/pubspec.yaml
+++ b/packages/camera/camera_windows/pubspec.yaml
@@ -1,8 +1,8 @@
 name: camera_windows
 description: A Flutter plugin for getting information about and controlling the camera on Windows.
-version: 0.1.0
 repository: https://github.com/flutter/plugins/tree/master/packages/camera/camera_windows
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+camera%22
+version: 0.1.0+1
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/espresso/CHANGELOG.md b/packages/espresso/CHANGELOG.md
index eb1f267..dad0a91 100644
--- a/packages/espresso/CHANGELOG.md
+++ b/packages/espresso/CHANGELOG.md
@@ -1,8 +1,13 @@
+## 0.2.0+2
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
+
 ## 0.2.0+1
 
 * Adds OS version support information to README.
 * Updates `androidx.test.ext:junit` and `androidx.test.ext:truth` for
-  compatibilty with updated Flutter template.
+  compatibility with updated Flutter template.
 
 ## 0.2.0
 
diff --git a/packages/espresso/example/lib/main.dart b/packages/espresso/example/lib/main.dart
index 14f94ab..741cd9c 100644
--- a/packages/espresso/example/lib/main.dart
+++ b/packages/espresso/example/lib/main.dart
@@ -4,10 +4,13 @@
 
 import 'package:flutter/material.dart';
 
-void main() => runApp(MyApp());
+void main() => runApp(const MyApp());
 
 /// Example app for Espresso plugin.
 class MyApp extends StatelessWidget {
+  /// Default Constructor
+  const MyApp({Key? key}) : super(key: key);
+
   // This widget is the root of your application.
   @override
   Widget build(BuildContext context) {
@@ -45,7 +48,7 @@
   final String title;
 
   @override
-  _MyHomePageState createState() => _MyHomePageState();
+  State<_MyHomePage> createState() => _MyHomePageState();
 }
 
 class _MyHomePageState extends State<_MyHomePage> {
diff --git a/packages/espresso/pubspec.yaml b/packages/espresso/pubspec.yaml
index 7737fc4..ac0199c 100644
--- a/packages/espresso/pubspec.yaml
+++ b/packages/espresso/pubspec.yaml
@@ -3,7 +3,7 @@
   Allows driving Flutter widgets from a native Espresso test.
 repository: https://github.com/flutter/plugins/tree/main/packages/espresso
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+espresso%22
-version: 0.2.0+1
+version: 0.2.0+2
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/file_selector/file_selector/CHANGELOG.md b/packages/file_selector/file_selector/CHANGELOG.md
index c0821fe..17baf9f 100644
--- a/packages/file_selector/file_selector/CHANGELOG.md
+++ b/packages/file_selector/file_selector/CHANGELOG.md
@@ -1,7 +1,9 @@
-## NEXT
+## 0.8.4+2
 
 * Removes unnecessary imports.
 * Adds OS version support information to README.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 0.8.4+1
 
diff --git a/packages/file_selector/file_selector/example/lib/get_directory_page.dart b/packages/file_selector/file_selector/example/lib/get_directory_page.dart
index b3ed9d0..506134d 100644
--- a/packages/file_selector/file_selector/example/lib/get_directory_page.dart
+++ b/packages/file_selector/file_selector/example/lib/get_directory_page.dart
@@ -7,6 +7,9 @@
 
 /// Screen that shows an example of getDirectoryPath
 class GetDirectoryPage extends StatelessWidget {
+  /// Default Constructor
+  const GetDirectoryPage({Key? key}) : super(key: key);
+
   Future<void> _getDirectoryPath(BuildContext context) async {
     const String confirmButtonText = 'Choose';
     final String? directoryPath = await getDirectoryPath(
@@ -50,7 +53,7 @@
 /// Widget that displays a text file in a dialog
 class TextDisplay extends StatelessWidget {
   /// Default Constructor
-  const TextDisplay(this.directoryPath);
+  const TextDisplay(this.directoryPath, {Key? key}) : super(key: key);
 
   /// Directory path
   final String directoryPath;
diff --git a/packages/file_selector/file_selector/example/lib/home_page.dart b/packages/file_selector/file_selector/example/lib/home_page.dart
index c598cbd..9a0733b 100644
--- a/packages/file_selector/file_selector/example/lib/home_page.dart
+++ b/packages/file_selector/file_selector/example/lib/home_page.dart
@@ -6,6 +6,9 @@
 
 /// Home Page of the application
 class HomePage extends StatelessWidget {
+  /// Default Constructor
+  const HomePage({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     final ButtonStyle style = ElevatedButton.styleFrom(
diff --git a/packages/file_selector/file_selector/example/lib/main.dart b/packages/file_selector/file_selector/example/lib/main.dart
index 14ce3f5..34f5857 100644
--- a/packages/file_selector/file_selector/example/lib/main.dart
+++ b/packages/file_selector/file_selector/example/lib/main.dart
@@ -11,11 +11,14 @@
 import 'package:flutter/material.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 /// MyApp is the Main Application
 class MyApp extends StatelessWidget {
+  /// Default Constructor
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     return MaterialApp(
@@ -24,13 +27,14 @@
         primarySwatch: Colors.blue,
         visualDensity: VisualDensity.adaptivePlatformDensity,
       ),
-      home: HomePage(),
+      home: const HomePage(),
       routes: <String, WidgetBuilder>{
-        '/open/image': (BuildContext context) => OpenImagePage(),
-        '/open/images': (BuildContext context) => OpenMultipleImagesPage(),
-        '/open/text': (BuildContext context) => OpenTextPage(),
+        '/open/image': (BuildContext context) => const OpenImagePage(),
+        '/open/images': (BuildContext context) =>
+            const OpenMultipleImagesPage(),
+        '/open/text': (BuildContext context) => const OpenTextPage(),
         '/save/text': (BuildContext context) => SaveTextPage(),
-        '/directory': (BuildContext context) => GetDirectoryPage(),
+        '/directory': (BuildContext context) => const GetDirectoryPage(),
       },
     );
   }
diff --git a/packages/file_selector/file_selector/example/lib/open_image_page.dart b/packages/file_selector/file_selector/example/lib/open_image_page.dart
index 0abdba6..e520ffb 100644
--- a/packages/file_selector/file_selector/example/lib/open_image_page.dart
+++ b/packages/file_selector/file_selector/example/lib/open_image_page.dart
@@ -10,6 +10,9 @@
 
 /// Screen that shows an example of openFiles
 class OpenImagePage extends StatelessWidget {
+  /// Default Constructor
+  const OpenImagePage({Key? key}) : super(key: key);
+
   Future<void> _openImageFile(BuildContext context) async {
     final XTypeGroup typeGroup = XTypeGroup(
       label: 'images',
@@ -59,7 +62,8 @@
 /// Widget that displays a text file in a dialog
 class ImageDisplay extends StatelessWidget {
   /// Default Constructor
-  const ImageDisplay(this.fileName, this.filePath);
+  const ImageDisplay(this.fileName, this.filePath, {Key? key})
+      : super(key: key);
 
   /// Image's name
   final String fileName;
diff --git a/packages/file_selector/file_selector/example/lib/open_multiple_images_page.dart b/packages/file_selector/file_selector/example/lib/open_multiple_images_page.dart
index 9a11012..e2d21c7 100644
--- a/packages/file_selector/file_selector/example/lib/open_multiple_images_page.dart
+++ b/packages/file_selector/file_selector/example/lib/open_multiple_images_page.dart
@@ -10,6 +10,9 @@
 
 /// Screen that shows an example of openFiles
 class OpenMultipleImagesPage extends StatelessWidget {
+  /// Default Constructor
+  const OpenMultipleImagesPage({Key? key}) : super(key: key);
+
   Future<void> _openImageFile(BuildContext context) async {
     final XTypeGroup jpgsTypeGroup = XTypeGroup(
       label: 'JPEGs',
@@ -61,7 +64,7 @@
 /// Widget that displays a text file in a dialog
 class MultipleImagesDisplay extends StatelessWidget {
   /// Default Constructor
-  const MultipleImagesDisplay(this.files);
+  const MultipleImagesDisplay(this.files, {Key? key}) : super(key: key);
 
   /// The files containing the images
   final List<XFile> files;
diff --git a/packages/file_selector/file_selector/example/lib/open_text_page.dart b/packages/file_selector/file_selector/example/lib/open_text_page.dart
index 652e859..be48a43 100644
--- a/packages/file_selector/file_selector/example/lib/open_text_page.dart
+++ b/packages/file_selector/file_selector/example/lib/open_text_page.dart
@@ -7,6 +7,9 @@
 
 /// Screen that shows an example of openFile
 class OpenTextPage extends StatelessWidget {
+  /// Default Constructor
+  const OpenTextPage({Key? key}) : super(key: key);
+
   Future<void> _openTextFile(BuildContext context) async {
     final XTypeGroup typeGroup = XTypeGroup(
       label: 'text',
@@ -55,7 +58,8 @@
 /// Widget that displays a text file in a dialog
 class TextDisplay extends StatelessWidget {
   /// Default Constructor
-  const TextDisplay(this.fileName, this.fileContent);
+  const TextDisplay(this.fileName, this.fileContent, {Key? key})
+      : super(key: key);
 
   /// File's name
   final String fileName;
diff --git a/packages/file_selector/file_selector/example/lib/save_text_page.dart b/packages/file_selector/file_selector/example/lib/save_text_page.dart
index 108ef89..b031784 100644
--- a/packages/file_selector/file_selector/example/lib/save_text_page.dart
+++ b/packages/file_selector/file_selector/example/lib/save_text_page.dart
@@ -8,6 +8,9 @@
 
 /// Page for showing an example of saving with file_selector
 class SaveTextPage extends StatelessWidget {
+  /// Default Constructor
+  SaveTextPage({Key? key}) : super(key: key);
+
   final TextEditingController _nameController = TextEditingController();
   final TextEditingController _contentController = TextEditingController();
 
diff --git a/packages/file_selector/file_selector/pubspec.yaml b/packages/file_selector/file_selector/pubspec.yaml
index c05900f..7026f7f 100644
--- a/packages/file_selector/file_selector/pubspec.yaml
+++ b/packages/file_selector/file_selector/pubspec.yaml
@@ -3,7 +3,7 @@
   directories, using native file selection UI.
 repository: https://github.com/flutter/plugins/tree/main/packages/file_selector/file_selector
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+file_selector%22
-version: 0.8.4+1
+version: 0.8.4+2
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/file_selector/file_selector_macos/CHANGELOG.md b/packages/file_selector/file_selector_macos/CHANGELOG.md
index b46a174..19724a5 100644
--- a/packages/file_selector/file_selector_macos/CHANGELOG.md
+++ b/packages/file_selector/file_selector_macos/CHANGELOG.md
@@ -1,6 +1,8 @@
-## NEXT
+## 0.8.2+1
 
 * Removes unnecessary imports.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 0.8.2
 
diff --git a/packages/file_selector/file_selector_macos/example/lib/get_directory_page.dart b/packages/file_selector/file_selector_macos/example/lib/get_directory_page.dart
index 0e55df8..a27ab2b 100644
--- a/packages/file_selector/file_selector_macos/example/lib/get_directory_page.dart
+++ b/packages/file_selector/file_selector_macos/example/lib/get_directory_page.dart
@@ -8,6 +8,9 @@
 /// Screen that allows the user to select a directory using `getDirectoryPath`,
 /// then displays the selected directory in a dialog.
 class GetDirectoryPage extends StatelessWidget {
+  /// Default Constructor
+  const GetDirectoryPage({Key? key}) : super(key: key);
+
   Future<void> _getDirectoryPath(BuildContext context) async {
     const String confirmButtonText = 'Choose';
     final String? directoryPath =
@@ -52,7 +55,7 @@
 /// Widget that displays a text file in a dialog.
 class TextDisplay extends StatelessWidget {
   /// Creates a `TextDisplay`.
-  const TextDisplay(this.directoryPath);
+  const TextDisplay(this.directoryPath, {Key? key}) : super(key: key);
 
   /// The path selected in the dialog.
   final String directoryPath;
diff --git a/packages/file_selector/file_selector_macos/example/lib/home_page.dart b/packages/file_selector/file_selector_macos/example/lib/home_page.dart
index 958680b..4d6ca7e 100644
--- a/packages/file_selector/file_selector_macos/example/lib/home_page.dart
+++ b/packages/file_selector/file_selector_macos/example/lib/home_page.dart
@@ -6,6 +6,9 @@
 
 /// Home Page of the application.
 class HomePage extends StatelessWidget {
+  /// Default Constructor
+  const HomePage({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     final ButtonStyle style = ElevatedButton.styleFrom(
diff --git a/packages/file_selector/file_selector_macos/example/lib/main.dart b/packages/file_selector/file_selector_macos/example/lib/main.dart
index a49ebac..cbe268e 100644
--- a/packages/file_selector/file_selector_macos/example/lib/main.dart
+++ b/packages/file_selector/file_selector_macos/example/lib/main.dart
@@ -11,11 +11,14 @@
 import 'package:flutter/material.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 /// MyApp is the Main Application.
 class MyApp extends StatelessWidget {
+  /// Default Constructor
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     return MaterialApp(
@@ -24,13 +27,14 @@
         primarySwatch: Colors.blue,
         visualDensity: VisualDensity.adaptivePlatformDensity,
       ),
-      home: HomePage(),
+      home: const HomePage(),
       routes: <String, WidgetBuilder>{
-        '/open/image': (BuildContext context) => OpenImagePage(),
-        '/open/images': (BuildContext context) => OpenMultipleImagesPage(),
-        '/open/text': (BuildContext context) => OpenTextPage(),
+        '/open/image': (BuildContext context) => const OpenImagePage(),
+        '/open/images': (BuildContext context) =>
+            const OpenMultipleImagesPage(),
+        '/open/text': (BuildContext context) => const OpenTextPage(),
         '/save/text': (BuildContext context) => SaveTextPage(),
-        '/directory': (BuildContext context) => GetDirectoryPage(),
+        '/directory': (BuildContext context) => const GetDirectoryPage(),
       },
     );
   }
diff --git a/packages/file_selector/file_selector_macos/example/lib/open_image_page.dart b/packages/file_selector/file_selector_macos/example/lib/open_image_page.dart
index aaf0836..1a05343 100644
--- a/packages/file_selector/file_selector_macos/example/lib/open_image_page.dart
+++ b/packages/file_selector/file_selector_macos/example/lib/open_image_page.dart
@@ -11,6 +11,9 @@
 /// Screen that allows the user to select an image file using
 /// `openFiles`, then displays the selected images in a gallery dialog.
 class OpenImagePage extends StatelessWidget {
+  /// Default Constructor
+  const OpenImagePage({Key? key}) : super(key: key);
+
   Future<void> _openImageFile(BuildContext context) async {
     final XTypeGroup typeGroup = XTypeGroup(
       label: 'images',
@@ -59,7 +62,8 @@
 /// Widget that displays an image in a dialog.
 class ImageDisplay extends StatelessWidget {
   /// Default Constructor.
-  const ImageDisplay(this.fileName, this.filePath);
+  const ImageDisplay(this.fileName, this.filePath, {Key? key})
+      : super(key: key);
 
   /// The name of the selected file.
   final String fileName;
diff --git a/packages/file_selector/file_selector_macos/example/lib/open_multiple_images_page.dart b/packages/file_selector/file_selector_macos/example/lib/open_multiple_images_page.dart
index a030b8b..9c3c8e3 100644
--- a/packages/file_selector/file_selector_macos/example/lib/open_multiple_images_page.dart
+++ b/packages/file_selector/file_selector_macos/example/lib/open_multiple_images_page.dart
@@ -11,6 +11,9 @@
 /// Screen that allows the user to select multiple image files using
 /// `openFiles`, then displays the selected images in a gallery dialog.
 class OpenMultipleImagesPage extends StatelessWidget {
+  /// Default Constructor
+  const OpenMultipleImagesPage({Key? key}) : super(key: key);
+
   Future<void> _openImageFile(BuildContext context) async {
     final XTypeGroup jpgsTypeGroup = XTypeGroup(
       label: 'JPEGs',
@@ -63,7 +66,7 @@
 /// Widget that displays a text file in a dialog.
 class MultipleImagesDisplay extends StatelessWidget {
   /// Default Constructor.
-  const MultipleImagesDisplay(this.files);
+  const MultipleImagesDisplay(this.files, {Key? key}) : super(key: key);
 
   /// The files containing the images.
   final List<XFile> files;
diff --git a/packages/file_selector/file_selector_macos/example/lib/open_text_page.dart b/packages/file_selector/file_selector_macos/example/lib/open_text_page.dart
index fa281a0..9adde40 100644
--- a/packages/file_selector/file_selector_macos/example/lib/open_text_page.dart
+++ b/packages/file_selector/file_selector_macos/example/lib/open_text_page.dart
@@ -8,6 +8,9 @@
 /// Screen that allows the user to select a text file using `openFile`, then
 /// displays its contents in a dialog.
 class OpenTextPage extends StatelessWidget {
+  /// Default Constructor
+  const OpenTextPage({Key? key}) : super(key: key);
+
   Future<void> _openTextFile(BuildContext context) async {
     final XTypeGroup typeGroup = XTypeGroup(
       label: 'text',
@@ -56,7 +59,8 @@
 /// Widget that displays a text file in a dialog.
 class TextDisplay extends StatelessWidget {
   /// Default Constructor.
-  const TextDisplay(this.fileName, this.fileContent);
+  const TextDisplay(this.fileName, this.fileContent, {Key? key})
+      : super(key: key);
 
   /// The name of the selected file.
   final String fileName;
diff --git a/packages/file_selector/file_selector_macos/example/lib/save_text_page.dart b/packages/file_selector/file_selector_macos/example/lib/save_text_page.dart
index 3989c62..a44a387 100644
--- a/packages/file_selector/file_selector_macos/example/lib/save_text_page.dart
+++ b/packages/file_selector/file_selector_macos/example/lib/save_text_page.dart
@@ -9,6 +9,9 @@
 /// Screen that allows the user to select a save location using `getSavePath`,
 /// then writes text to a file at that location.
 class SaveTextPage extends StatelessWidget {
+  /// Default Constructor
+  SaveTextPage({Key? key}) : super(key: key);
+
   final TextEditingController _nameController = TextEditingController();
   final TextEditingController _contentController = TextEditingController();
 
@@ -67,8 +70,8 @@
                 primary: Colors.blue,
                 onPrimary: Colors.white,
               ),
-              child: const Text('Press to save a text file'),
               onPressed: _saveFile,
+              child: const Text('Press to save a text file'),
             ),
           ],
         ),
diff --git a/packages/file_selector/file_selector_macos/pubspec.yaml b/packages/file_selector/file_selector_macos/pubspec.yaml
index 071d261..41077c1 100644
--- a/packages/file_selector/file_selector_macos/pubspec.yaml
+++ b/packages/file_selector/file_selector_macos/pubspec.yaml
@@ -2,7 +2,7 @@
 description: macOS implementation of the file_selector plugin.
 repository: https://github.com/flutter/plugins/tree/master/packages/file_selector/file_selector_macos
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+file_selector%22
-version: 0.8.2
+version: 0.8.2+1
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/file_selector/file_selector_web/CHANGELOG.md b/packages/file_selector/file_selector_web/CHANGELOG.md
index 5927239..ce9d559 100644
--- a/packages/file_selector/file_selector_web/CHANGELOG.md
+++ b/packages/file_selector/file_selector_web/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 0.8.1+4
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
+
 ## 0.8.1+3
 
 * Minor code cleanup for new analysis rules.
diff --git a/packages/file_selector/file_selector_web/example/lib/main.dart b/packages/file_selector/file_selector_web/example/lib/main.dart
index 341913a..8742295 100644
--- a/packages/file_selector/file_selector_web/example/lib/main.dart
+++ b/packages/file_selector/file_selector_web/example/lib/main.dart
@@ -5,13 +5,16 @@
 import 'package:flutter/material.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 /// App for testing
 class MyApp extends StatefulWidget {
+  /// Default Constructor
+  const MyApp({Key? key}) : super(key: key);
+
   @override
-  _MyAppState createState() => _MyAppState();
+  State<MyApp> createState() => _MyAppState();
 }
 
 class _MyAppState extends State<MyApp> {
diff --git a/packages/file_selector/file_selector_web/pubspec.yaml b/packages/file_selector/file_selector_web/pubspec.yaml
index 74d0412..2e12b6d 100644
--- a/packages/file_selector/file_selector_web/pubspec.yaml
+++ b/packages/file_selector/file_selector_web/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Web platform implementation of file_selector
 repository: https://github.com/flutter/plugins/tree/main/packages/file_selector/file_selector_web
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+file_selector%22
-version: 0.8.1+3
+version: 0.8.1+4
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/file_selector/file_selector_windows/CHANGELOG.md b/packages/file_selector/file_selector_windows/CHANGELOG.md
index ae3cd13..c242717 100644
--- a/packages/file_selector/file_selector_windows/CHANGELOG.md
+++ b/packages/file_selector/file_selector_windows/CHANGELOG.md
@@ -1,6 +1,8 @@
-## NEXT
+## 0.8.2+1
 
 * Removes unnecessary imports.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 0.8.2
 
diff --git a/packages/file_selector/file_selector_windows/example/lib/get_directory_page.dart b/packages/file_selector/file_selector_windows/example/lib/get_directory_page.dart
index b282b90..8fc1a90 100644
--- a/packages/file_selector/file_selector_windows/example/lib/get_directory_page.dart
+++ b/packages/file_selector/file_selector_windows/example/lib/get_directory_page.dart
@@ -8,6 +8,9 @@
 /// Screen that allows the user to select a directory using `getDirectoryPath`,
 ///  then displays the selected directory in a dialog.
 class GetDirectoryPage extends StatelessWidget {
+  /// Default Constructor
+  const GetDirectoryPage({Key? key}) : super(key: key);
+
   Future<void> _getDirectoryPath(BuildContext context) async {
     const String confirmButtonText = 'Choose';
     final String? directoryPath =
@@ -52,7 +55,7 @@
 /// Widget that displays a text file in a dialog.
 class TextDisplay extends StatelessWidget {
   /// Creates a `TextDisplay`.
-  const TextDisplay(this.directoryPath);
+  const TextDisplay(this.directoryPath, {Key? key}) : super(key: key);
 
   /// The path selected in the dialog.
   final String directoryPath;
diff --git a/packages/file_selector/file_selector_windows/example/lib/home_page.dart b/packages/file_selector/file_selector_windows/example/lib/home_page.dart
index 958680b..4d6ca7e 100644
--- a/packages/file_selector/file_selector_windows/example/lib/home_page.dart
+++ b/packages/file_selector/file_selector_windows/example/lib/home_page.dart
@@ -6,6 +6,9 @@
 
 /// Home Page of the application.
 class HomePage extends StatelessWidget {
+  /// Default Constructor
+  const HomePage({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     final ButtonStyle style = ElevatedButton.styleFrom(
diff --git a/packages/file_selector/file_selector_windows/example/lib/main.dart b/packages/file_selector/file_selector_windows/example/lib/main.dart
index a49ebac..cbe268e 100644
--- a/packages/file_selector/file_selector_windows/example/lib/main.dart
+++ b/packages/file_selector/file_selector_windows/example/lib/main.dart
@@ -11,11 +11,14 @@
 import 'package:flutter/material.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 /// MyApp is the Main Application.
 class MyApp extends StatelessWidget {
+  /// Default Constructor
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     return MaterialApp(
@@ -24,13 +27,14 @@
         primarySwatch: Colors.blue,
         visualDensity: VisualDensity.adaptivePlatformDensity,
       ),
-      home: HomePage(),
+      home: const HomePage(),
       routes: <String, WidgetBuilder>{
-        '/open/image': (BuildContext context) => OpenImagePage(),
-        '/open/images': (BuildContext context) => OpenMultipleImagesPage(),
-        '/open/text': (BuildContext context) => OpenTextPage(),
+        '/open/image': (BuildContext context) => const OpenImagePage(),
+        '/open/images': (BuildContext context) =>
+            const OpenMultipleImagesPage(),
+        '/open/text': (BuildContext context) => const OpenTextPage(),
         '/save/text': (BuildContext context) => SaveTextPage(),
-        '/directory': (BuildContext context) => GetDirectoryPage(),
+        '/directory': (BuildContext context) => const GetDirectoryPage(),
       },
     );
   }
diff --git a/packages/file_selector/file_selector_windows/example/lib/open_image_page.dart b/packages/file_selector/file_selector_windows/example/lib/open_image_page.dart
index aaf0836..1a05343 100644
--- a/packages/file_selector/file_selector_windows/example/lib/open_image_page.dart
+++ b/packages/file_selector/file_selector_windows/example/lib/open_image_page.dart
@@ -11,6 +11,9 @@
 /// Screen that allows the user to select an image file using
 /// `openFiles`, then displays the selected images in a gallery dialog.
 class OpenImagePage extends StatelessWidget {
+  /// Default Constructor
+  const OpenImagePage({Key? key}) : super(key: key);
+
   Future<void> _openImageFile(BuildContext context) async {
     final XTypeGroup typeGroup = XTypeGroup(
       label: 'images',
@@ -59,7 +62,8 @@
 /// Widget that displays an image in a dialog.
 class ImageDisplay extends StatelessWidget {
   /// Default Constructor.
-  const ImageDisplay(this.fileName, this.filePath);
+  const ImageDisplay(this.fileName, this.filePath, {Key? key})
+      : super(key: key);
 
   /// The name of the selected file.
   final String fileName;
diff --git a/packages/file_selector/file_selector_windows/example/lib/open_multiple_images_page.dart b/packages/file_selector/file_selector_windows/example/lib/open_multiple_images_page.dart
index a030b8b..9c3c8e3 100644
--- a/packages/file_selector/file_selector_windows/example/lib/open_multiple_images_page.dart
+++ b/packages/file_selector/file_selector_windows/example/lib/open_multiple_images_page.dart
@@ -11,6 +11,9 @@
 /// Screen that allows the user to select multiple image files using
 /// `openFiles`, then displays the selected images in a gallery dialog.
 class OpenMultipleImagesPage extends StatelessWidget {
+  /// Default Constructor
+  const OpenMultipleImagesPage({Key? key}) : super(key: key);
+
   Future<void> _openImageFile(BuildContext context) async {
     final XTypeGroup jpgsTypeGroup = XTypeGroup(
       label: 'JPEGs',
@@ -63,7 +66,7 @@
 /// Widget that displays a text file in a dialog.
 class MultipleImagesDisplay extends StatelessWidget {
   /// Default Constructor.
-  const MultipleImagesDisplay(this.files);
+  const MultipleImagesDisplay(this.files, {Key? key}) : super(key: key);
 
   /// The files containing the images.
   final List<XFile> files;
diff --git a/packages/file_selector/file_selector_windows/example/lib/open_text_page.dart b/packages/file_selector/file_selector_windows/example/lib/open_text_page.dart
index fa281a0..9adde40 100644
--- a/packages/file_selector/file_selector_windows/example/lib/open_text_page.dart
+++ b/packages/file_selector/file_selector_windows/example/lib/open_text_page.dart
@@ -8,6 +8,9 @@
 /// Screen that allows the user to select a text file using `openFile`, then
 /// displays its contents in a dialog.
 class OpenTextPage extends StatelessWidget {
+  /// Default Constructor
+  const OpenTextPage({Key? key}) : super(key: key);
+
   Future<void> _openTextFile(BuildContext context) async {
     final XTypeGroup typeGroup = XTypeGroup(
       label: 'text',
@@ -56,7 +59,8 @@
 /// Widget that displays a text file in a dialog.
 class TextDisplay extends StatelessWidget {
   /// Default Constructor.
-  const TextDisplay(this.fileName, this.fileContent);
+  const TextDisplay(this.fileName, this.fileContent, {Key? key})
+      : super(key: key);
 
   /// The name of the selected file.
   final String fileName;
diff --git a/packages/file_selector/file_selector_windows/example/lib/save_text_page.dart b/packages/file_selector/file_selector_windows/example/lib/save_text_page.dart
index b87a51c..961e0fb 100644
--- a/packages/file_selector/file_selector_windows/example/lib/save_text_page.dart
+++ b/packages/file_selector/file_selector_windows/example/lib/save_text_page.dart
@@ -9,6 +9,9 @@
 /// Screen that allows the user to select a save location using `getSavePath`,
 /// then writes text to a file at that location.
 class SaveTextPage extends StatelessWidget {
+  /// Default Constructor
+  SaveTextPage({Key? key}) : super(key: key);
+
   final TextEditingController _nameController = TextEditingController();
   final TextEditingController _contentController = TextEditingController();
 
@@ -67,8 +70,8 @@
                 primary: Colors.blue,
                 onPrimary: Colors.white,
               ),
-              child: const Text('Press to save a text file'),
               onPressed: _saveFile,
+              child: const Text('Press to save a text file'),
             ),
           ],
         ),
diff --git a/packages/file_selector/file_selector_windows/pubspec.yaml b/packages/file_selector/file_selector_windows/pubspec.yaml
index 7b035e9..152b63e 100644
--- a/packages/file_selector/file_selector_windows/pubspec.yaml
+++ b/packages/file_selector/file_selector_windows/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Windows implementation of the file_selector plugin.
 repository: https://github.com/flutter/plugins/tree/master/packages/file_selector/file_selector_windows
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+file_selector%22
-version: 0.8.2
+version: 0.8.2+1
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/flutter_plugin_android_lifecycle/CHANGELOG.md b/packages/flutter_plugin_android_lifecycle/CHANGELOG.md
index 8fdfc39..a0a3f67 100644
--- a/packages/flutter_plugin_android_lifecycle/CHANGELOG.md
+++ b/packages/flutter_plugin_android_lifecycle/CHANGELOG.md
@@ -1,6 +1,8 @@
-## NEXT
+## 2.0.6
 
 * Adds OS version support information to README.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 2.0.5
 
diff --git a/packages/flutter_plugin_android_lifecycle/example/integration_test/flutter_plugin_android_lifecycle_test.dart b/packages/flutter_plugin_android_lifecycle/example/integration_test/flutter_plugin_android_lifecycle_test.dart
index 1d329a0..1198c6f 100644
--- a/packages/flutter_plugin_android_lifecycle/example/integration_test/flutter_plugin_android_lifecycle_test.dart
+++ b/packages/flutter_plugin_android_lifecycle/example/integration_test/flutter_plugin_android_lifecycle_test.dart
@@ -10,6 +10,6 @@
   IntegrationTestWidgetsFlutterBinding.ensureInitialized();
 
   testWidgets('loads', (WidgetTester tester) async {
-    await tester.pumpWidget(MyApp());
+    await tester.pumpWidget(const MyApp());
   });
 }
diff --git a/packages/flutter_plugin_android_lifecycle/example/lib/main.dart b/packages/flutter_plugin_android_lifecycle/example/lib/main.dart
index 3ef6794..c465b3b 100644
--- a/packages/flutter_plugin_android_lifecycle/example/lib/main.dart
+++ b/packages/flutter_plugin_android_lifecycle/example/lib/main.dart
@@ -2,13 +2,15 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// ignore_for_file: public_member_api_docs
-
 import 'package:flutter/material.dart';
 
-void main() => runApp(MyApp());
+void main() => runApp(const MyApp());
 
+/// MyApp is the Main Application.
 class MyApp extends StatelessWidget {
+  /// Default Constructor
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     return MaterialApp(
diff --git a/packages/flutter_plugin_android_lifecycle/pubspec.yaml b/packages/flutter_plugin_android_lifecycle/pubspec.yaml
index b359cc5..c109d09 100644
--- a/packages/flutter_plugin_android_lifecycle/pubspec.yaml
+++ b/packages/flutter_plugin_android_lifecycle/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Flutter plugin for accessing an Android Lifecycle within other plugins.
 repository: https://github.com/flutter/plugins/tree/main/packages/flutter_plugin_android_lifecycle
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+flutter_plugin_android_lifecycle%22
-version: 2.0.5
+version: 2.0.6
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/google_maps_flutter/google_maps_flutter/CHANGELOG.md b/packages/google_maps_flutter/google_maps_flutter/CHANGELOG.md
index b0662b8..d1f2f92 100644
--- a/packages/google_maps_flutter/google_maps_flutter/CHANGELOG.md
+++ b/packages/google_maps_flutter/google_maps_flutter/CHANGELOG.md
@@ -1,6 +1,8 @@
-## NEXT
+## 2.1.5
 
 * Removes unnecessary imports.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 2.1.4
 
@@ -223,7 +225,7 @@
 
 ## 0.5.26+1
 
-* Removes a errorneously added method from the GoogleMapController.h header file.
+* Removes an erroneously added method from the GoogleMapController.h header file.
 
 ## 0.5.26
 
diff --git a/packages/google_maps_flutter/google_maps_flutter/example/lib/animate_camera.dart b/packages/google_maps_flutter/google_maps_flutter/example/lib/animate_camera.dart
index f8072ee..09df2b9 100644
--- a/packages/google_maps_flutter/google_maps_flutter/example/lib/animate_camera.dart
+++ b/packages/google_maps_flutter/google_maps_flutter/example/lib/animate_camera.dart
@@ -10,8 +10,8 @@
 import 'page.dart';
 
 class AnimateCameraPage extends GoogleMapExampleAppPage {
-  const AnimateCameraPage()
-      : super(const Icon(Icons.map), 'Camera control, animated');
+  const AnimateCameraPage({Key? key})
+      : super(const Icon(Icons.map), 'Camera control, animated', key: key);
 
   @override
   Widget build(BuildContext context) {
@@ -20,7 +20,7 @@
 }
 
 class AnimateCamera extends StatefulWidget {
-  const AnimateCamera();
+  const AnimateCamera({Key? key}) : super(key: key);
   @override
   State createState() => AnimateCameraState();
 }
diff --git a/packages/google_maps_flutter/google_maps_flutter/example/lib/lite_mode.dart b/packages/google_maps_flutter/google_maps_flutter/example/lib/lite_mode.dart
index b1b58fd..fd95cf8 100644
--- a/packages/google_maps_flutter/google_maps_flutter/example/lib/lite_mode.dart
+++ b/packages/google_maps_flutter/google_maps_flutter/example/lib/lite_mode.dart
@@ -12,7 +12,8 @@
     CameraPosition(target: LatLng(-33.852, 151.211), zoom: 11.0);
 
 class LiteModePage extends GoogleMapExampleAppPage {
-  const LiteModePage() : super(const Icon(Icons.map), 'Lite mode');
+  const LiteModePage({Key? key})
+      : super(const Icon(Icons.map), 'Lite mode', key: key);
 
   @override
   Widget build(BuildContext context) {
diff --git a/packages/google_maps_flutter/google_maps_flutter/example/lib/main.dart b/packages/google_maps_flutter/google_maps_flutter/example/lib/main.dart
index f4d420a..8932705 100644
--- a/packages/google_maps_flutter/google_maps_flutter/example/lib/main.dart
+++ b/packages/google_maps_flutter/google_maps_flutter/example/lib/main.dart
@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// ignore_for_file: public_member_api_docs
-
 import 'package:flutter/foundation.dart';
 import 'package:flutter/material.dart';
 
@@ -43,7 +41,11 @@
   const TileOverlayPage(),
 ];
 
+/// MapsDemo is the Main Application.
 class MapsDemo extends StatelessWidget {
+  /// Default Constructor
+  const MapsDemo({Key? key}) : super(key: key);
+
   void _pushPage(BuildContext context, GoogleMapExampleAppPage page) {
     Navigator.of(context).push(MaterialPageRoute<void>(
         builder: (_) => Scaffold(
@@ -72,5 +74,5 @@
   if (defaultTargetPlatform == TargetPlatform.android) {
     AndroidGoogleMapsFlutter.useAndroidViewSurface = true;
   }
-  runApp(MaterialApp(home: MapsDemo()));
+  runApp(const MaterialApp(home: MapsDemo()));
 }
diff --git a/packages/google_maps_flutter/google_maps_flutter/example/lib/map_click.dart b/packages/google_maps_flutter/google_maps_flutter/example/lib/map_click.dart
index bbe2372..9c96f25 100644
--- a/packages/google_maps_flutter/google_maps_flutter/example/lib/map_click.dart
+++ b/packages/google_maps_flutter/google_maps_flutter/example/lib/map_click.dart
@@ -12,7 +12,8 @@
     CameraPosition(target: LatLng(-33.852, 151.211), zoom: 11.0);
 
 class MapClickPage extends GoogleMapExampleAppPage {
-  const MapClickPage() : super(const Icon(Icons.mouse), 'Map click');
+  const MapClickPage({Key? key})
+      : super(const Icon(Icons.mouse), 'Map click', key: key);
 
   @override
   Widget build(BuildContext context) {
diff --git a/packages/google_maps_flutter/google_maps_flutter/example/lib/map_coordinates.dart b/packages/google_maps_flutter/google_maps_flutter/example/lib/map_coordinates.dart
index 8e4853c..1179acd 100644
--- a/packages/google_maps_flutter/google_maps_flutter/example/lib/map_coordinates.dart
+++ b/packages/google_maps_flutter/google_maps_flutter/example/lib/map_coordinates.dart
@@ -12,7 +12,8 @@
     CameraPosition(target: LatLng(-33.852, 151.211), zoom: 11.0);
 
 class MapCoordinatesPage extends GoogleMapExampleAppPage {
-  const MapCoordinatesPage() : super(const Icon(Icons.map), 'Map coordinates');
+  const MapCoordinatesPage({Key? key})
+      : super(const Icon(Icons.map), 'Map coordinates', key: key);
 
   @override
   Widget build(BuildContext context) {
diff --git a/packages/google_maps_flutter/google_maps_flutter/example/lib/map_ui.dart b/packages/google_maps_flutter/google_maps_flutter/example/lib/map_ui.dart
index 48ef1f5..fbfeda5 100644
--- a/packages/google_maps_flutter/google_maps_flutter/example/lib/map_ui.dart
+++ b/packages/google_maps_flutter/google_maps_flutter/example/lib/map_ui.dart
@@ -16,7 +16,8 @@
 );
 
 class MapUiPage extends GoogleMapExampleAppPage {
-  const MapUiPage() : super(const Icon(Icons.map), 'User interface');
+  const MapUiPage({Key? key})
+      : super(const Icon(Icons.map), 'User interface', key: key);
 
   @override
   Widget build(BuildContext context) {
@@ -25,7 +26,7 @@
 }
 
 class MapUiBody extends StatefulWidget {
-  const MapUiBody();
+  const MapUiBody({Key? key}) : super(key: key);
 
   @override
   State<StatefulWidget> createState() => MapUiBodyState();
diff --git a/packages/google_maps_flutter/google_maps_flutter/example/lib/marker_icons.dart b/packages/google_maps_flutter/google_maps_flutter/example/lib/marker_icons.dart
index 95ace9d..58d266c 100644
--- a/packages/google_maps_flutter/google_maps_flutter/example/lib/marker_icons.dart
+++ b/packages/google_maps_flutter/google_maps_flutter/example/lib/marker_icons.dart
@@ -11,7 +11,8 @@
 import 'page.dart';
 
 class MarkerIconsPage extends GoogleMapExampleAppPage {
-  const MarkerIconsPage() : super(const Icon(Icons.image), 'Marker icons');
+  const MarkerIconsPage({Key? key})
+      : super(const Icon(Icons.image), 'Marker icons', key: key);
 
   @override
   Widget build(BuildContext context) {
@@ -20,7 +21,7 @@
 }
 
 class MarkerIconsBody extends StatefulWidget {
-  const MarkerIconsBody();
+  const MarkerIconsBody({Key? key}) : super(key: key);
 
   @override
   State<StatefulWidget> createState() => MarkerIconsBodyState();
diff --git a/packages/google_maps_flutter/google_maps_flutter/example/lib/move_camera.dart b/packages/google_maps_flutter/google_maps_flutter/example/lib/move_camera.dart
index 33da90f..a6bae30 100644
--- a/packages/google_maps_flutter/google_maps_flutter/example/lib/move_camera.dart
+++ b/packages/google_maps_flutter/google_maps_flutter/example/lib/move_camera.dart
@@ -10,7 +10,8 @@
 import 'page.dart';
 
 class MoveCameraPage extends GoogleMapExampleAppPage {
-  const MoveCameraPage() : super(const Icon(Icons.map), 'Camera control');
+  const MoveCameraPage({Key? key})
+      : super(const Icon(Icons.map), 'Camera control', key: key);
 
   @override
   Widget build(BuildContext context) {
@@ -19,7 +20,7 @@
 }
 
 class MoveCamera extends StatefulWidget {
-  const MoveCamera();
+  const MoveCamera({Key? key}) : super(key: key);
   @override
   State createState() => MoveCameraState();
 }
diff --git a/packages/google_maps_flutter/google_maps_flutter/example/lib/padding.dart b/packages/google_maps_flutter/google_maps_flutter/example/lib/padding.dart
index 7709190..a4bfa88 100644
--- a/packages/google_maps_flutter/google_maps_flutter/example/lib/padding.dart
+++ b/packages/google_maps_flutter/google_maps_flutter/example/lib/padding.dart
@@ -9,7 +9,8 @@
 import 'page.dart';
 
 class PaddingPage extends GoogleMapExampleAppPage {
-  const PaddingPage() : super(const Icon(Icons.map), 'Add padding to the map');
+  const PaddingPage({Key? key})
+      : super(const Icon(Icons.map), 'Add padding to the map', key: key);
 
   @override
   Widget build(BuildContext context) {
@@ -18,7 +19,7 @@
 }
 
 class MarkerIconsBody extends StatefulWidget {
-  const MarkerIconsBody();
+  const MarkerIconsBody({Key? key}) : super(key: key);
 
   @override
   State<StatefulWidget> createState() => MarkerIconsBodyState();
diff --git a/packages/google_maps_flutter/google_maps_flutter/example/lib/page.dart b/packages/google_maps_flutter/google_maps_flutter/example/lib/page.dart
index fb6eb32..eb01ab0 100644
--- a/packages/google_maps_flutter/google_maps_flutter/example/lib/page.dart
+++ b/packages/google_maps_flutter/google_maps_flutter/example/lib/page.dart
@@ -7,7 +7,8 @@
 import 'package:flutter/material.dart';
 
 abstract class GoogleMapExampleAppPage extends StatelessWidget {
-  const GoogleMapExampleAppPage(this.leading, this.title);
+  const GoogleMapExampleAppPage(this.leading, this.title, {Key? key})
+      : super(key: key);
 
   final Widget leading;
   final String title;
diff --git a/packages/google_maps_flutter/google_maps_flutter/example/lib/place_circle.dart b/packages/google_maps_flutter/google_maps_flutter/example/lib/place_circle.dart
index c6f1509..ef5033c 100644
--- a/packages/google_maps_flutter/google_maps_flutter/example/lib/place_circle.dart
+++ b/packages/google_maps_flutter/google_maps_flutter/example/lib/place_circle.dart
@@ -10,8 +10,8 @@
 import 'page.dart';
 
 class PlaceCirclePage extends GoogleMapExampleAppPage {
-  const PlaceCirclePage()
-      : super(const Icon(Icons.linear_scale), 'Place circle');
+  const PlaceCirclePage({Key? key})
+      : super(const Icon(Icons.linear_scale), 'Place circle', key: key);
 
   @override
   Widget build(BuildContext context) {
@@ -20,7 +20,7 @@
 }
 
 class PlaceCircleBody extends StatefulWidget {
-  const PlaceCircleBody();
+  const PlaceCircleBody({Key? key}) : super(key: key);
 
   @override
   State<StatefulWidget> createState() => PlaceCircleBodyState();
@@ -170,42 +170,42 @@
                     Column(
                       children: <Widget>[
                         TextButton(
-                          child: const Text('add'),
                           onPressed: _add,
+                          child: const Text('add'),
                         ),
                         TextButton(
-                          child: const Text('remove'),
                           onPressed: (selectedId == null)
                               ? null
                               : () => _remove(selectedId),
+                          child: const Text('remove'),
                         ),
                         TextButton(
-                          child: const Text('toggle visible'),
                           onPressed: (selectedId == null)
                               ? null
                               : () => _toggleVisible(selectedId),
+                          child: const Text('toggle visible'),
                         ),
                       ],
                     ),
                     Column(
                       children: <Widget>[
                         TextButton(
-                          child: const Text('change stroke width'),
                           onPressed: (selectedId == null)
                               ? null
                               : () => _changeStrokeWidth(selectedId),
+                          child: const Text('change stroke width'),
                         ),
                         TextButton(
-                          child: const Text('change stroke color'),
                           onPressed: (selectedId == null)
                               ? null
                               : () => _changeStrokeColor(selectedId),
+                          child: const Text('change stroke color'),
                         ),
                         TextButton(
-                          child: const Text('change fill color'),
                           onPressed: (selectedId == null)
                               ? null
                               : () => _changeFillColor(selectedId),
+                          child: const Text('change fill color'),
                         ),
                       ],
                     )
diff --git a/packages/google_maps_flutter/google_maps_flutter/example/lib/place_marker.dart b/packages/google_maps_flutter/google_maps_flutter/example/lib/place_marker.dart
index 4291cac..1238d61 100644
--- a/packages/google_maps_flutter/google_maps_flutter/example/lib/place_marker.dart
+++ b/packages/google_maps_flutter/google_maps_flutter/example/lib/place_marker.dart
@@ -15,7 +15,8 @@
 import 'page.dart';
 
 class PlaceMarkerPage extends GoogleMapExampleAppPage {
-  const PlaceMarkerPage() : super(const Icon(Icons.place), 'Place marker');
+  const PlaceMarkerPage({Key? key})
+      : super(const Icon(Icons.place), 'Place marker', key: key);
 
   @override
   Widget build(BuildContext context) {
@@ -24,7 +25,7 @@
 }
 
 class PlaceMarkerBody extends StatefulWidget {
-  const PlaceMarkerBody();
+  const PlaceMarkerBody({Key? key}) : super(key: key);
 
   @override
   State<StatefulWidget> createState() => PlaceMarkerBodyState();
@@ -308,13 +309,13 @@
             mainAxisAlignment: MainAxisAlignment.spaceEvenly,
             children: <Widget>[
               TextButton(
-                child: const Text('Add'),
                 onPressed: _add,
+                child: const Text('Add'),
               ),
               TextButton(
-                child: const Text('Remove'),
                 onPressed:
                     selectedId == null ? null : () => _remove(selectedId),
+                child: const Text('Remove'),
               ),
             ],
           ),
@@ -322,62 +323,61 @@
             alignment: WrapAlignment.spaceEvenly,
             children: <Widget>[
               TextButton(
-                child: const Text('change info'),
                 onPressed:
                     selectedId == null ? null : () => _changeInfo(selectedId),
+                child: const Text('change info'),
               ),
               TextButton(
-                child: const Text('change info anchor'),
                 onPressed: selectedId == null
                     ? null
                     : () => _changeInfoAnchor(selectedId),
+                child: const Text('change info anchor'),
               ),
               TextButton(
-                child: const Text('change alpha'),
                 onPressed:
                     selectedId == null ? null : () => _changeAlpha(selectedId),
+                child: const Text('change alpha'),
               ),
               TextButton(
-                child: const Text('change anchor'),
                 onPressed:
                     selectedId == null ? null : () => _changeAnchor(selectedId),
+                child: const Text('change anchor'),
               ),
               TextButton(
-                child: const Text('toggle draggable'),
                 onPressed: selectedId == null
                     ? null
                     : () => _toggleDraggable(selectedId),
+                child: const Text('toggle draggable'),
               ),
               TextButton(
-                child: const Text('toggle flat'),
                 onPressed:
                     selectedId == null ? null : () => _toggleFlat(selectedId),
+                child: const Text('toggle flat'),
               ),
               TextButton(
-                child: const Text('change position'),
                 onPressed: selectedId == null
                     ? null
                     : () => _changePosition(selectedId),
+                child: const Text('change position'),
               ),
               TextButton(
-                child: const Text('change rotation'),
                 onPressed: selectedId == null
                     ? null
                     : () => _changeRotation(selectedId),
+                child: const Text('change rotation'),
               ),
               TextButton(
-                child: const Text('toggle visible'),
                 onPressed: selectedId == null
                     ? null
                     : () => _toggleVisible(selectedId),
+                child: const Text('toggle visible'),
               ),
               TextButton(
-                child: const Text('change zIndex'),
                 onPressed:
                     selectedId == null ? null : () => _changeZIndex(selectedId),
+                child: const Text('change zIndex'),
               ),
               TextButton(
-                child: const Text('set marker icon'),
                 onPressed: selectedId == null
                     ? null
                     : () {
@@ -387,6 +387,7 @@
                           },
                         );
                       },
+                child: const Text('set marker icon'),
               ),
             ],
           ),
diff --git a/packages/google_maps_flutter/google_maps_flutter/example/lib/place_polygon.dart b/packages/google_maps_flutter/google_maps_flutter/example/lib/place_polygon.dart
index 8d4fa3e..f193214 100644
--- a/packages/google_maps_flutter/google_maps_flutter/example/lib/place_polygon.dart
+++ b/packages/google_maps_flutter/google_maps_flutter/example/lib/place_polygon.dart
@@ -10,8 +10,8 @@
 import 'page.dart';
 
 class PlacePolygonPage extends GoogleMapExampleAppPage {
-  const PlacePolygonPage()
-      : super(const Icon(Icons.linear_scale), 'Place polygon');
+  const PlacePolygonPage({Key? key})
+      : super(const Icon(Icons.linear_scale), 'Place polygon', key: key);
 
   @override
   Widget build(BuildContext context) {
@@ -20,7 +20,7 @@
 }
 
 class PlacePolygonBody extends StatefulWidget {
-  const PlacePolygonBody();
+  const PlacePolygonBody({Key? key}) : super(key: key);
 
   @override
   State<StatefulWidget> createState() => PlacePolygonBodyState();
@@ -196,64 +196,64 @@
                     Column(
                       children: <Widget>[
                         TextButton(
-                          child: const Text('add'),
                           onPressed: _add,
+                          child: const Text('add'),
                         ),
                         TextButton(
-                          child: const Text('remove'),
                           onPressed: (selectedId == null)
                               ? null
                               : () => _remove(selectedId),
+                          child: const Text('remove'),
                         ),
                         TextButton(
-                          child: const Text('toggle visible'),
                           onPressed: (selectedId == null)
                               ? null
                               : () => _toggleVisible(selectedId),
+                          child: const Text('toggle visible'),
                         ),
                         TextButton(
-                          child: const Text('toggle geodesic'),
                           onPressed: (selectedId == null)
                               ? null
                               : () => _toggleGeodesic(selectedId),
+                          child: const Text('toggle geodesic'),
                         ),
                       ],
                     ),
                     Column(
                       children: <Widget>[
                         TextButton(
-                          child: const Text('add holes'),
                           onPressed: (selectedId == null)
                               ? null
                               : ((polygons[selectedId]!.holes.isNotEmpty)
                                   ? null
                                   : () => _addHoles(selectedId)),
+                          child: const Text('add holes'),
                         ),
                         TextButton(
-                          child: const Text('remove holes'),
                           onPressed: (selectedId == null)
                               ? null
                               : ((polygons[selectedId]!.holes.isEmpty)
                                   ? null
                                   : () => _removeHoles(selectedId)),
+                          child: const Text('remove holes'),
                         ),
                         TextButton(
-                          child: const Text('change stroke width'),
                           onPressed: (selectedId == null)
                               ? null
                               : () => _changeWidth(selectedId),
+                          child: const Text('change stroke width'),
                         ),
                         TextButton(
-                          child: const Text('change stroke color'),
                           onPressed: (selectedId == null)
                               ? null
                               : () => _changeStrokeColor(selectedId),
+                          child: const Text('change stroke color'),
                         ),
                         TextButton(
-                          child: const Text('change fill color'),
                           onPressed: (selectedId == null)
                               ? null
                               : () => _changeFillColor(selectedId),
+                          child: const Text('change fill color'),
                         ),
                       ],
                     )
diff --git a/packages/google_maps_flutter/google_maps_flutter/example/lib/place_polyline.dart b/packages/google_maps_flutter/google_maps_flutter/example/lib/place_polyline.dart
index 434920d..b3a637c 100644
--- a/packages/google_maps_flutter/google_maps_flutter/example/lib/place_polyline.dart
+++ b/packages/google_maps_flutter/google_maps_flutter/example/lib/place_polyline.dart
@@ -11,8 +11,8 @@
 import 'page.dart';
 
 class PlacePolylinePage extends GoogleMapExampleAppPage {
-  const PlacePolylinePage()
-      : super(const Icon(Icons.linear_scale), 'Place polyline');
+  const PlacePolylinePage({Key? key})
+      : super(const Icon(Icons.linear_scale), 'Place polyline', key: key);
 
   @override
   Widget build(BuildContext context) {
@@ -21,7 +21,7 @@
 }
 
 class PlacePolylineBody extends StatefulWidget {
-  const PlacePolylineBody();
+  const PlacePolylineBody({Key? key}) : super(key: key);
 
   @override
   State<StatefulWidget> createState() => PlacePolylineBodyState();
@@ -234,66 +234,66 @@
                     Column(
                       children: <Widget>[
                         TextButton(
-                          child: const Text('add'),
                           onPressed: _add,
+                          child: const Text('add'),
                         ),
                         TextButton(
-                          child: const Text('remove'),
                           onPressed: (selectedId == null)
                               ? null
                               : () => _remove(selectedId),
+                          child: const Text('remove'),
                         ),
                         TextButton(
-                          child: const Text('toggle visible'),
                           onPressed: (selectedId == null)
                               ? null
                               : () => _toggleVisible(selectedId),
+                          child: const Text('toggle visible'),
                         ),
                         TextButton(
-                          child: const Text('toggle geodesic'),
                           onPressed: (selectedId == null)
                               ? null
                               : () => _toggleGeodesic(selectedId),
+                          child: const Text('toggle geodesic'),
                         ),
                       ],
                     ),
                     Column(
                       children: <Widget>[
                         TextButton(
-                          child: const Text('change width'),
                           onPressed: (selectedId == null)
                               ? null
                               : () => _changeWidth(selectedId),
+                          child: const Text('change width'),
                         ),
                         TextButton(
-                          child: const Text('change color'),
                           onPressed: (selectedId == null)
                               ? null
                               : () => _changeColor(selectedId),
+                          child: const Text('change color'),
                         ),
                         TextButton(
-                          child: const Text('change start cap [Android only]'),
                           onPressed: isIOS || (selectedId == null)
                               ? null
                               : () => _changeStartCap(selectedId),
+                          child: const Text('change start cap [Android only]'),
                         ),
                         TextButton(
-                          child: const Text('change end cap [Android only]'),
                           onPressed: isIOS || (selectedId == null)
                               ? null
                               : () => _changeEndCap(selectedId),
+                          child: const Text('change end cap [Android only]'),
                         ),
                         TextButton(
-                          child: const Text('change joint type [Android only]'),
                           onPressed: isIOS || (selectedId == null)
                               ? null
                               : () => _changeJointType(selectedId),
+                          child: const Text('change joint type [Android only]'),
                         ),
                         TextButton(
-                          child: const Text('change pattern [Android only]'),
                           onPressed: isIOS || (selectedId == null)
                               ? null
                               : () => _changePattern(selectedId),
+                          child: const Text('change pattern [Android only]'),
                         ),
                       ],
                     )
diff --git a/packages/google_maps_flutter/google_maps_flutter/example/lib/scrolling_map.dart b/packages/google_maps_flutter/google_maps_flutter/example/lib/scrolling_map.dart
index 0476931..ca9d396 100644
--- a/packages/google_maps_flutter/google_maps_flutter/example/lib/scrolling_map.dart
+++ b/packages/google_maps_flutter/google_maps_flutter/example/lib/scrolling_map.dart
@@ -14,7 +14,8 @@
 const LatLng _center = LatLng(32.080664, 34.9563837);
 
 class ScrollingMapPage extends GoogleMapExampleAppPage {
-  const ScrollingMapPage() : super(const Icon(Icons.map), 'Scrolling map');
+  const ScrollingMapPage({Key? key})
+      : super(const Icon(Icons.map), 'Scrolling map', key: key);
 
   @override
   Widget build(BuildContext context) {
@@ -23,7 +24,7 @@
 }
 
 class ScrollingMapBody extends StatelessWidget {
-  const ScrollingMapBody();
+  const ScrollingMapBody({Key? key}) : super(key: key);
 
   @override
   Widget build(BuildContext context) {
diff --git a/packages/google_maps_flutter/google_maps_flutter/example/lib/snapshot.dart b/packages/google_maps_flutter/google_maps_flutter/example/lib/snapshot.dart
index 9afc288..849a9f4 100644
--- a/packages/google_maps_flutter/google_maps_flutter/example/lib/snapshot.dart
+++ b/packages/google_maps_flutter/google_maps_flutter/example/lib/snapshot.dart
@@ -15,8 +15,9 @@
     CameraPosition(target: LatLng(-33.852, 151.211), zoom: 11.0);
 
 class SnapshotPage extends GoogleMapExampleAppPage {
-  const SnapshotPage()
-      : super(const Icon(Icons.camera_alt), 'Take a snapshot of the map');
+  const SnapshotPage({Key? key})
+      : super(const Icon(Icons.camera_alt), 'Take a snapshot of the map',
+            key: key);
 
   @override
   Widget build(BuildContext context) {
diff --git a/packages/google_maps_flutter/google_maps_flutter/example/lib/tile_overlay.dart b/packages/google_maps_flutter/google_maps_flutter/example/lib/tile_overlay.dart
index dc7f7d1..81dfc28 100644
--- a/packages/google_maps_flutter/google_maps_flutter/example/lib/tile_overlay.dart
+++ b/packages/google_maps_flutter/google_maps_flutter/example/lib/tile_overlay.dart
@@ -13,7 +13,8 @@
 import 'page.dart';
 
 class TileOverlayPage extends GoogleMapExampleAppPage {
-  const TileOverlayPage() : super(const Icon(Icons.map), 'Tile overlay');
+  const TileOverlayPage({Key? key})
+      : super(const Icon(Icons.map), 'Tile overlay', key: key);
 
   @override
   Widget build(BuildContext context) {
@@ -22,7 +23,7 @@
 }
 
 class TileOverlayBody extends StatefulWidget {
-  const TileOverlayBody();
+  const TileOverlayBody({Key? key}) : super(key: key);
 
   @override
   State<StatefulWidget> createState() => TileOverlayBodyState();
@@ -90,16 +91,16 @@
           ),
         ),
         TextButton(
-          child: const Text('Add tile overlay'),
           onPressed: _addTileOverlay,
+          child: const Text('Add tile overlay'),
         ),
         TextButton(
-          child: const Text('Remove tile overlay'),
           onPressed: _removeTileOverlay,
+          child: const Text('Remove tile overlay'),
         ),
         TextButton(
-          child: const Text('Clear tile cache'),
           onPressed: _clearTileCache,
+          child: const Text('Clear tile cache'),
         ),
       ],
     );
diff --git a/packages/google_maps_flutter/google_maps_flutter/lib/src/controller.dart b/packages/google_maps_flutter/google_maps_flutter/lib/src/controller.dart
index 088589e..dfc6e57 100644
--- a/packages/google_maps_flutter/google_maps_flutter/lib/src/controller.dart
+++ b/packages/google_maps_flutter/google_maps_flutter/lib/src/controller.dart
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+// ignore_for_file: library_private_types_in_public_api
+
 part of google_maps_flutter;
 
 /// Controller for a single GoogleMap instance running on the host platform.
diff --git a/packages/google_maps_flutter/google_maps_flutter/pubspec.yaml b/packages/google_maps_flutter/google_maps_flutter/pubspec.yaml
index c10f9c6..a294dd0 100644
--- a/packages/google_maps_flutter/google_maps_flutter/pubspec.yaml
+++ b/packages/google_maps_flutter/google_maps_flutter/pubspec.yaml
@@ -2,7 +2,7 @@
 description: A Flutter plugin for integrating Google Maps in iOS and Android applications.
 repository: https://github.com/flutter/plugins/tree/main/packages/google_maps_flutter/google_maps_flutter
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+maps%22
-version: 2.1.4
+version: 2.1.5
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/google_maps_flutter/google_maps_flutter_web/CHANGELOG.md b/packages/google_maps_flutter/google_maps_flutter_web/CHANGELOG.md
index 48908b9..f2fe971 100644
--- a/packages/google_maps_flutter/google_maps_flutter_web/CHANGELOG.md
+++ b/packages/google_maps_flutter/google_maps_flutter_web/CHANGELOG.md
@@ -1,6 +1,8 @@
-## NEXT
+## 0.3.2+2
 
 * Removes unnecessary imports.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 0.3.2+1
 
diff --git a/packages/google_maps_flutter/google_maps_flutter_web/example/lib/main.dart b/packages/google_maps_flutter/google_maps_flutter_web/example/lib/main.dart
index 1041520..d1ba571 100644
--- a/packages/google_maps_flutter/google_maps_flutter_web/example/lib/main.dart
+++ b/packages/google_maps_flutter/google_maps_flutter_web/example/lib/main.dart
@@ -11,7 +11,7 @@
 /// App for testing
 class MyApp extends StatefulWidget {
   @override
-  _MyAppState createState() => _MyAppState();
+  State<MyApp> createState() => _MyAppState();
 }
 
 class _MyAppState extends State<MyApp> {
diff --git a/packages/google_maps_flutter/google_maps_flutter_web/pubspec.yaml b/packages/google_maps_flutter/google_maps_flutter_web/pubspec.yaml
index 2780175..271d87d 100644
--- a/packages/google_maps_flutter/google_maps_flutter_web/pubspec.yaml
+++ b/packages/google_maps_flutter/google_maps_flutter_web/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Web platform implementation of google_maps_flutter
 repository: https://github.com/flutter/plugins/tree/main/packages/google_maps_flutter/google_maps_flutter_web
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+maps%22
-version: 0.3.2+1
+version: 0.3.2+2
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/google_sign_in/google_sign_in/CHANGELOG.md b/packages/google_sign_in/google_sign_in/CHANGELOG.md
index caab46d..5b47536 100644
--- a/packages/google_sign_in/google_sign_in/CHANGELOG.md
+++ b/packages/google_sign_in/google_sign_in/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 5.3.1
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
+
 ## 5.3.0
 
 * Moves Android and iOS implementations to federated packages.
diff --git a/packages/google_sign_in/google_sign_in/example/lib/main.dart b/packages/google_sign_in/google_sign_in/example/lib/main.dart
index 9840a1e..4c27543 100644
--- a/packages/google_sign_in/google_sign_in/example/lib/main.dart
+++ b/packages/google_sign_in/google_sign_in/example/lib/main.dart
@@ -22,7 +22,7 @@
 
 void main() {
   runApp(
-    MaterialApp(
+    const MaterialApp(
       title: 'Google Sign In',
       home: SignInDemo(),
     ),
@@ -30,6 +30,8 @@
 }
 
 class SignInDemo extends StatefulWidget {
+  const SignInDemo({Key? key}) : super(key: key);
+
   @override
   State createState() => SignInDemoState();
 }
@@ -125,8 +127,8 @@
           const Text('Signed in successfully.'),
           Text(_contactText),
           ElevatedButton(
-            child: const Text('SIGN OUT'),
             onPressed: _handleSignOut,
+            child: const Text('SIGN OUT'),
           ),
           ElevatedButton(
             child: const Text('REFRESH'),
@@ -140,8 +142,8 @@
         children: <Widget>[
           const Text('You are not currently signed in.'),
           ElevatedButton(
-            child: const Text('SIGN IN'),
             onPressed: _handleSignIn,
+            child: const Text('SIGN IN'),
           ),
         ],
       );
diff --git a/packages/google_sign_in/google_sign_in/lib/widgets.dart b/packages/google_sign_in/google_sign_in/lib/widgets.dart
index 61f8913..f7ae5f9 100644
--- a/packages/google_sign_in/google_sign_in/lib/widgets.dart
+++ b/packages/google_sign_in/google_sign_in/lib/widgets.dart
@@ -22,11 +22,13 @@
   /// in place of a profile photo, or a default profile photo if the user's
   /// identity does not specify a `displayName`.
   const GoogleUserCircleAvatar({
+    Key? key,
     required this.identity,
     this.placeholderPhotoUrl,
     this.foregroundColor,
     this.backgroundColor,
-  }) : assert(identity != null);
+  })  : assert(identity != null),
+        super(key: key);
 
   /// A regular expression that matches against the "size directive" path
   /// segment of Google profile image URLs.
diff --git a/packages/google_sign_in/google_sign_in/pubspec.yaml b/packages/google_sign_in/google_sign_in/pubspec.yaml
index 760706f..e58b27a 100644
--- a/packages/google_sign_in/google_sign_in/pubspec.yaml
+++ b/packages/google_sign_in/google_sign_in/pubspec.yaml
@@ -3,7 +3,7 @@
   for signing in with a Google account on Android and iOS.
 repository: https://github.com/flutter/plugins/tree/main/packages/google_sign_in/google_sign_in
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+google_sign_in%22
-version: 5.3.0
+version: 5.3.1
 
 
 environment:
diff --git a/packages/google_sign_in/google_sign_in_android/CHANGELOG.md b/packages/google_sign_in/google_sign_in_android/CHANGELOG.md
index 3ffa6b5..90069d0 100644
--- a/packages/google_sign_in/google_sign_in_android/CHANGELOG.md
+++ b/packages/google_sign_in/google_sign_in_android/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 5.2.7
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
+
 ## 5.2.6
 
 * Switches to an internal method channel, rather than the default.
diff --git a/packages/google_sign_in/google_sign_in_android/example/lib/main.dart b/packages/google_sign_in/google_sign_in_android/example/lib/main.dart
index a750c33..526cf8b 100644
--- a/packages/google_sign_in/google_sign_in_android/example/lib/main.dart
+++ b/packages/google_sign_in/google_sign_in_android/example/lib/main.dart
@@ -14,7 +14,7 @@
 
 void main() {
   runApp(
-    MaterialApp(
+    const MaterialApp(
       title: 'Google Sign In',
       home: SignInDemo(),
     ),
@@ -22,6 +22,8 @@
 }
 
 class SignInDemo extends StatefulWidget {
+  const SignInDemo({Key? key}) : super(key: key);
+
   @override
   State createState() => SignInDemoState();
 }
@@ -142,8 +144,8 @@
           const Text('Signed in successfully.'),
           Text(_contactText),
           ElevatedButton(
-            child: const Text('SIGN OUT'),
             onPressed: _handleSignOut,
+            child: const Text('SIGN OUT'),
           ),
           ElevatedButton(
             child: const Text('REFRESH'),
@@ -157,8 +159,8 @@
         children: <Widget>[
           const Text('You are not currently signed in.'),
           ElevatedButton(
-            child: const Text('SIGN IN'),
             onPressed: _handleSignIn,
+            child: const Text('SIGN IN'),
           ),
         ],
       );
diff --git a/packages/google_sign_in/google_sign_in_android/pubspec.yaml b/packages/google_sign_in/google_sign_in_android/pubspec.yaml
index fa3dc14..d9b2723 100644
--- a/packages/google_sign_in/google_sign_in_android/pubspec.yaml
+++ b/packages/google_sign_in/google_sign_in_android/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Android implementation of the google_sign_in plugin.
 repository: https://github.com/flutter/plugins/tree/main/packages/google_sign_in/google_sign_in_android
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+google_sign_in%22
-version: 5.2.6
+version: 5.2.7
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/google_sign_in/google_sign_in_ios/CHANGELOG.md b/packages/google_sign_in/google_sign_in_ios/CHANGELOG.md
index 3ffa6b5..90069d0 100644
--- a/packages/google_sign_in/google_sign_in_ios/CHANGELOG.md
+++ b/packages/google_sign_in/google_sign_in_ios/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 5.2.7
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
+
 ## 5.2.6
 
 * Switches to an internal method channel, rather than the default.
diff --git a/packages/google_sign_in/google_sign_in_ios/example/lib/main.dart b/packages/google_sign_in/google_sign_in_ios/example/lib/main.dart
index a750c33..526cf8b 100644
--- a/packages/google_sign_in/google_sign_in_ios/example/lib/main.dart
+++ b/packages/google_sign_in/google_sign_in_ios/example/lib/main.dart
@@ -14,7 +14,7 @@
 
 void main() {
   runApp(
-    MaterialApp(
+    const MaterialApp(
       title: 'Google Sign In',
       home: SignInDemo(),
     ),
@@ -22,6 +22,8 @@
 }
 
 class SignInDemo extends StatefulWidget {
+  const SignInDemo({Key? key}) : super(key: key);
+
   @override
   State createState() => SignInDemoState();
 }
@@ -142,8 +144,8 @@
           const Text('Signed in successfully.'),
           Text(_contactText),
           ElevatedButton(
-            child: const Text('SIGN OUT'),
             onPressed: _handleSignOut,
+            child: const Text('SIGN OUT'),
           ),
           ElevatedButton(
             child: const Text('REFRESH'),
@@ -157,8 +159,8 @@
         children: <Widget>[
           const Text('You are not currently signed in.'),
           ElevatedButton(
-            child: const Text('SIGN IN'),
             onPressed: _handleSignIn,
+            child: const Text('SIGN IN'),
           ),
         ],
       );
diff --git a/packages/google_sign_in/google_sign_in_ios/pubspec.yaml b/packages/google_sign_in/google_sign_in_ios/pubspec.yaml
index e5ef383..b6f541b 100644
--- a/packages/google_sign_in/google_sign_in_ios/pubspec.yaml
+++ b/packages/google_sign_in/google_sign_in_ios/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Android implementation of the google_sign_in plugin.
 repository: https://github.com/flutter/plugins/tree/main/packages/google_sign_in/google_sign_in_ios
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+google_sign_in%22
-version: 5.2.6
+version: 5.2.7
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/google_sign_in/google_sign_in_web/CHANGELOG.md b/packages/google_sign_in/google_sign_in_web/CHANGELOG.md
index aab4aca..6e87beb 100644
--- a/packages/google_sign_in/google_sign_in_web/CHANGELOG.md
+++ b/packages/google_sign_in/google_sign_in_web/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 0.10.1+1
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
+
 ## 0.10.1
 
 * Updates minimum Flutter version to 2.8.
diff --git a/packages/google_sign_in/google_sign_in_web/example/lib/main.dart b/packages/google_sign_in/google_sign_in_web/example/lib/main.dart
index d381fb4..b23015c 100644
--- a/packages/google_sign_in/google_sign_in_web/example/lib/main.dart
+++ b/packages/google_sign_in/google_sign_in_web/example/lib/main.dart
@@ -5,13 +5,16 @@
 import 'package:flutter/material.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 /// App for testing
 class MyApp extends StatefulWidget {
+  /// Default Constructor
+  const MyApp({Key? key}) : super(key: key);
+
   @override
-  _MyAppState createState() => _MyAppState();
+  State<MyApp> createState() => _MyAppState();
 }
 
 class _MyAppState extends State<MyApp> {
diff --git a/packages/google_sign_in/google_sign_in_web/pubspec.yaml b/packages/google_sign_in/google_sign_in_web/pubspec.yaml
index 5a09453..3dcd0e8 100644
--- a/packages/google_sign_in/google_sign_in_web/pubspec.yaml
+++ b/packages/google_sign_in/google_sign_in_web/pubspec.yaml
@@ -3,7 +3,7 @@
   for signing in with a Google account on Android, iOS and Web.
 repository: https://github.com/flutter/plugins/tree/main/packages/google_sign_in/google_sign_in_web
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+google_sign_in%22
-version: 0.10.1
+version: 0.10.1+1
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/image_picker/image_picker/CHANGELOG.md b/packages/image_picker/image_picker/CHANGELOG.md
index f1bf54c..a384a52 100644
--- a/packages/image_picker/image_picker/CHANGELOG.md
+++ b/packages/image_picker/image_picker/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 0.8.5+1
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
+
 ## 0.8.5
 
 * Moves Android and iOS implementations to federated packages.
diff --git a/packages/image_picker/image_picker/example/lib/main.dart b/packages/image_picker/image_picker/example/lib/main.dart
index f3ad237..a6f0e83 100755
--- a/packages/image_picker/image_picker/example/lib/main.dart
+++ b/packages/image_picker/image_picker/example/lib/main.dart
@@ -13,10 +13,12 @@
 import 'package:video_player/video_player.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 class MyApp extends StatelessWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     return const MaterialApp(
@@ -32,7 +34,7 @@
   final String? title;
 
   @override
-  _MyHomePageState createState() => _MyHomePageState();
+  State<MyHomePage> createState() => _MyHomePageState();
 }
 
 class _MyHomePageState extends State<MyHomePage> {
@@ -177,21 +179,22 @@
     }
     if (_imageFileList != null) {
       return Semantics(
-          child: ListView.builder(
-            key: UniqueKey(),
-            itemBuilder: (BuildContext context, int index) {
-              // Why network for web?
-              // See https://pub.dev/packages/image_picker#getting-ready-for-the-web-platform
-              return Semantics(
-                label: 'image_picker_example_picked_image',
-                child: kIsWeb
-                    ? Image.network(_imageFileList![index].path)
-                    : Image.file(File(_imageFileList![index].path)),
-              );
-            },
-            itemCount: _imageFileList!.length,
-          ),
-          label: 'image_picker_example_picked_images');
+        label: 'image_picker_example_picked_images',
+        child: ListView.builder(
+          key: UniqueKey(),
+          itemBuilder: (BuildContext context, int index) {
+            // Why network for web?
+            // See https://pub.dev/packages/image_picker#getting-ready-for-the-web-platform
+            return Semantics(
+              label: 'image_picker_example_picked_image',
+              child: kIsWeb
+                  ? Image.network(_imageFileList![index].path)
+                  : Image.file(File(_imageFileList![index].path)),
+            );
+          },
+          itemCount: _imageFileList!.length,
+        ),
+      );
     } else if (_pickImageError != null) {
       return Text(
         'Pick image error: $_pickImageError',
@@ -417,7 +420,7 @@
     double? maxWidth, double? maxHeight, int? quality);
 
 class AspectRatioVideo extends StatefulWidget {
-  const AspectRatioVideo(this.controller);
+  const AspectRatioVideo(this.controller, {Key? key}) : super(key: key);
 
   final VideoPlayerController? controller;
 
diff --git a/packages/image_picker/image_picker/pubspec.yaml b/packages/image_picker/image_picker/pubspec.yaml
index 77a5091..818486d 100755
--- a/packages/image_picker/image_picker/pubspec.yaml
+++ b/packages/image_picker/image_picker/pubspec.yaml
@@ -3,7 +3,7 @@
   library, and taking new pictures with the camera.
 repository: https://github.com/flutter/plugins/tree/main/packages/image_picker/image_picker
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+image_picker%22
-version: 0.8.5
+version: 0.8.5+1
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/image_picker/image_picker_android/CHANGELOG.md b/packages/image_picker/image_picker_android/CHANGELOG.md
index 3472ade..0514fc3 100644
--- a/packages/image_picker/image_picker_android/CHANGELOG.md
+++ b/packages/image_picker/image_picker_android/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 0.8.4+12
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
+
 ## 0.8.4+11
 
 * Splits from `image_picker` as a federated implementation.
diff --git a/packages/image_picker/image_picker_android/example/lib/main.dart b/packages/image_picker/image_picker_android/example/lib/main.dart
index 48eee35..d56aeb8 100755
--- a/packages/image_picker/image_picker_android/example/lib/main.dart
+++ b/packages/image_picker/image_picker_android/example/lib/main.dart
@@ -13,10 +13,12 @@
 import 'package:video_player/video_player.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 class MyApp extends StatelessWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     return const MaterialApp(
@@ -32,7 +34,7 @@
   final String? title;
 
   @override
-  _MyHomePageState createState() => _MyHomePageState();
+  State<MyHomePage> createState() => _MyHomePageState();
 }
 
 class _MyHomePageState extends State<MyHomePage> {
@@ -177,21 +179,22 @@
     }
     if (_imageFileList != null) {
       return Semantics(
-          child: ListView.builder(
-            key: UniqueKey(),
-            itemBuilder: (BuildContext context, int index) {
-              // Why network for web?
-              // See https://pub.dev/packages/image_picker#getting-ready-for-the-web-platform
-              return Semantics(
-                label: 'image_picker_example_picked_image',
-                child: kIsWeb
-                    ? Image.network(_imageFileList![index].path)
-                    : Image.file(File(_imageFileList![index].path)),
-              );
-            },
-            itemCount: _imageFileList!.length,
-          ),
-          label: 'image_picker_example_picked_images');
+        label: 'image_picker_example_picked_images',
+        child: ListView.builder(
+          key: UniqueKey(),
+          itemBuilder: (BuildContext context, int index) {
+            // Why network for web?
+            // See https://pub.dev/packages/image_picker#getting-ready-for-the-web-platform
+            return Semantics(
+              label: 'image_picker_example_picked_image',
+              child: kIsWeb
+                  ? Image.network(_imageFileList![index].path)
+                  : Image.file(File(_imageFileList![index].path)),
+            );
+          },
+          itemCount: _imageFileList!.length,
+        ),
+      );
     } else if (_pickImageError != null) {
       return Text(
         'Pick image error: $_pickImageError',
@@ -417,7 +420,7 @@
     double? maxWidth, double? maxHeight, int? quality);
 
 class AspectRatioVideo extends StatefulWidget {
-  const AspectRatioVideo(this.controller);
+  const AspectRatioVideo(this.controller, {Key? key}) : super(key: key);
 
   final VideoPlayerController? controller;
 
diff --git a/packages/image_picker/image_picker_android/pubspec.yaml b/packages/image_picker/image_picker_android/pubspec.yaml
index dbeef9b..90d136c 100755
--- a/packages/image_picker/image_picker_android/pubspec.yaml
+++ b/packages/image_picker/image_picker_android/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Android implementation of the image_picker plugin.
 repository: https://github.com/flutter/plugins/tree/main/packages/image_picker/image_picker_android
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+image_picker%22
-version: 0.8.4+11
+version: 0.8.4+12
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/image_picker/image_picker_for_web/CHANGELOG.md b/packages/image_picker/image_picker_for_web/CHANGELOG.md
index dcf353f..c33b3b9 100644
--- a/packages/image_picker/image_picker_for_web/CHANGELOG.md
+++ b/packages/image_picker/image_picker_for_web/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 2.1.7
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
+
 ## 2.1.6
 
 * Internal code cleanup for stricter analysis options.
diff --git a/packages/image_picker/image_picker_for_web/example/lib/main.dart b/packages/image_picker/image_picker_for_web/example/lib/main.dart
index 341913a..8742295 100644
--- a/packages/image_picker/image_picker_for_web/example/lib/main.dart
+++ b/packages/image_picker/image_picker_for_web/example/lib/main.dart
@@ -5,13 +5,16 @@
 import 'package:flutter/material.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 /// App for testing
 class MyApp extends StatefulWidget {
+  /// Default Constructor
+  const MyApp({Key? key}) : super(key: key);
+
   @override
-  _MyAppState createState() => _MyAppState();
+  State<MyApp> createState() => _MyAppState();
 }
 
 class _MyAppState extends State<MyApp> {
diff --git a/packages/image_picker/image_picker_for_web/pubspec.yaml b/packages/image_picker/image_picker_for_web/pubspec.yaml
index deccd2b..b0c5deb 100644
--- a/packages/image_picker/image_picker_for_web/pubspec.yaml
+++ b/packages/image_picker/image_picker_for_web/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Web platform implementation of image_picker
 repository: https://github.com/flutter/plugins/tree/main/packages/image_picker/image_picker_for_web
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+image_picker%22
-version: 2.1.6
+version: 2.1.7
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/image_picker/image_picker_ios/CHANGELOG.md b/packages/image_picker/image_picker_ios/CHANGELOG.md
index 31a0795..af391db 100644
--- a/packages/image_picker/image_picker_ios/CHANGELOG.md
+++ b/packages/image_picker/image_picker_ios/CHANGELOG.md
@@ -1,6 +1,8 @@
-## NEXT
+## 0.8.5+1
 
 * Removes unnecessary imports.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 0.8.5
 
diff --git a/packages/image_picker/image_picker_ios/example/lib/main.dart b/packages/image_picker/image_picker_ios/example/lib/main.dart
index 48eee35..d56aeb8 100755
--- a/packages/image_picker/image_picker_ios/example/lib/main.dart
+++ b/packages/image_picker/image_picker_ios/example/lib/main.dart
@@ -13,10 +13,12 @@
 import 'package:video_player/video_player.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 class MyApp extends StatelessWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     return const MaterialApp(
@@ -32,7 +34,7 @@
   final String? title;
 
   @override
-  _MyHomePageState createState() => _MyHomePageState();
+  State<MyHomePage> createState() => _MyHomePageState();
 }
 
 class _MyHomePageState extends State<MyHomePage> {
@@ -177,21 +179,22 @@
     }
     if (_imageFileList != null) {
       return Semantics(
-          child: ListView.builder(
-            key: UniqueKey(),
-            itemBuilder: (BuildContext context, int index) {
-              // Why network for web?
-              // See https://pub.dev/packages/image_picker#getting-ready-for-the-web-platform
-              return Semantics(
-                label: 'image_picker_example_picked_image',
-                child: kIsWeb
-                    ? Image.network(_imageFileList![index].path)
-                    : Image.file(File(_imageFileList![index].path)),
-              );
-            },
-            itemCount: _imageFileList!.length,
-          ),
-          label: 'image_picker_example_picked_images');
+        label: 'image_picker_example_picked_images',
+        child: ListView.builder(
+          key: UniqueKey(),
+          itemBuilder: (BuildContext context, int index) {
+            // Why network for web?
+            // See https://pub.dev/packages/image_picker#getting-ready-for-the-web-platform
+            return Semantics(
+              label: 'image_picker_example_picked_image',
+              child: kIsWeb
+                  ? Image.network(_imageFileList![index].path)
+                  : Image.file(File(_imageFileList![index].path)),
+            );
+          },
+          itemCount: _imageFileList!.length,
+        ),
+      );
     } else if (_pickImageError != null) {
       return Text(
         'Pick image error: $_pickImageError',
@@ -417,7 +420,7 @@
     double? maxWidth, double? maxHeight, int? quality);
 
 class AspectRatioVideo extends StatefulWidget {
-  const AspectRatioVideo(this.controller);
+  const AspectRatioVideo(this.controller, {Key? key}) : super(key: key);
 
   final VideoPlayerController? controller;
 
diff --git a/packages/image_picker/image_picker_ios/pubspec.yaml b/packages/image_picker/image_picker_ios/pubspec.yaml
index a9cd052..76ca206 100755
--- a/packages/image_picker/image_picker_ios/pubspec.yaml
+++ b/packages/image_picker/image_picker_ios/pubspec.yaml
@@ -2,7 +2,7 @@
 description: iOS implementation of the video_picker plugin.
 repository: https://github.com/flutter/plugins/tree/main/packages/image_picker/image_picker_ios
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+image_picker%22
-version: 0.8.5
+version: 0.8.5+1
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/image_picker/image_picker_windows/CHANGELOG.md b/packages/image_picker/image_picker_windows/CHANGELOG.md
index d98656b..e72ab24 100644
--- a/packages/image_picker/image_picker_windows/CHANGELOG.md
+++ b/packages/image_picker/image_picker_windows/CHANGELOG.md
@@ -1,6 +1,8 @@
-## NEXT
+## 0.1.0+1
 
 * Removes unnecessary imports.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 0.1.0
 
diff --git a/packages/image_picker/image_picker_windows/example/lib/main.dart b/packages/image_picker/image_picker_windows/example/lib/main.dart
index 577d6da..b3ba357 100644
--- a/packages/image_picker/image_picker_windows/example/lib/main.dart
+++ b/packages/image_picker/image_picker_windows/example/lib/main.dart
@@ -12,10 +12,12 @@
 import 'package:video_player/video_player.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 class MyApp extends StatelessWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     return const MaterialApp(
@@ -31,7 +33,7 @@
   final String? title;
 
   @override
-  _MyHomePageState createState() => _MyHomePageState();
+  State<MyHomePage> createState() => _MyHomePageState();
 }
 
 class _MyHomePageState extends State<MyHomePage> {
@@ -176,17 +178,18 @@
     }
     if (_imageFileList != null) {
       return Semantics(
-          child: ListView.builder(
-            key: UniqueKey(),
-            itemBuilder: (BuildContext context, int index) {
-              return Semantics(
-                label: 'image_picker_example_picked_image',
-                child: Image.file(File(_imageFileList![index].path)),
-              );
-            },
-            itemCount: _imageFileList!.length,
-          ),
-          label: 'image_picker_example_picked_images');
+        label: 'image_picker_example_picked_images',
+        child: ListView.builder(
+          key: UniqueKey(),
+          itemBuilder: (BuildContext context, int index) {
+            return Semantics(
+              label: 'image_picker_example_picked_image',
+              child: Image.file(File(_imageFileList![index].path)),
+            );
+          },
+          itemCount: _imageFileList!.length,
+        ),
+      );
     } else if (_pickImageError != null) {
       return Text(
         'Pick image error: $_pickImageError',
@@ -363,7 +366,7 @@
     double? maxWidth, double? maxHeight, int? quality);
 
 class AspectRatioVideo extends StatefulWidget {
-  const AspectRatioVideo(this.controller);
+  const AspectRatioVideo(this.controller, {Key? key}) : super(key: key);
 
   final VideoPlayerController? controller;
 
diff --git a/packages/image_picker/image_picker_windows/pubspec.yaml b/packages/image_picker/image_picker_windows/pubspec.yaml
index eec41f7..afadf3e 100644
--- a/packages/image_picker/image_picker_windows/pubspec.yaml
+++ b/packages/image_picker/image_picker_windows/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Windows platform implementation of image_picker
 repository: https://github.com/flutter/plugins/tree/main/packages/image_picker/image_picker_windows
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+image_picker%22
-version: 0.1.0
+version: 0.1.0+1
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/in_app_purchase/in_app_purchase/CHANGELOG.md b/packages/in_app_purchase/in_app_purchase/CHANGELOG.md
index 24ef9ea..8412c23 100644
--- a/packages/in_app_purchase/in_app_purchase/CHANGELOG.md
+++ b/packages/in_app_purchase/in_app_purchase/CHANGELOG.md
@@ -1,7 +1,9 @@
-## NEXT
+## 3.0.3
 
 * Removes unnecessary imports.
 * Adds OS version support information to README.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 3.0.2
 
diff --git a/packages/in_app_purchase/in_app_purchase/example/lib/main.dart b/packages/in_app_purchase/in_app_purchase/example/lib/main.dart
index 651652b..34346a0 100644
--- a/packages/in_app_purchase/in_app_purchase/example/lib/main.dart
+++ b/packages/in_app_purchase/in_app_purchase/example/lib/main.dart
@@ -33,7 +33,7 @@
 
 class _MyApp extends StatefulWidget {
   @override
-  _MyAppState createState() => _MyAppState();
+  State<_MyApp> createState() => _MyAppState();
 }
 
 class _MyAppState extends State<_MyApp> {
@@ -247,60 +247,61 @@
       (ProductDetails productDetails) {
         final PurchaseDetails? previousPurchase = purchases[productDetails.id];
         return ListTile(
-            title: Text(
-              productDetails.title,
-            ),
-            subtitle: Text(
-              productDetails.description,
-            ),
-            trailing: previousPurchase != null
-                ? IconButton(
-                    onPressed: () => confirmPriceChange(context),
-                    icon: const Icon(Icons.upgrade))
-                : TextButton(
-                    child: Text(productDetails.price),
-                    style: TextButton.styleFrom(
-                      backgroundColor: Colors.green[800],
-                      primary: Colors.white,
-                    ),
-                    onPressed: () {
-                      late PurchaseParam purchaseParam;
+          title: Text(
+            productDetails.title,
+          ),
+          subtitle: Text(
+            productDetails.description,
+          ),
+          trailing: previousPurchase != null
+              ? IconButton(
+                  onPressed: () => confirmPriceChange(context),
+                  icon: const Icon(Icons.upgrade))
+              : TextButton(
+                  style: TextButton.styleFrom(
+                    backgroundColor: Colors.green[800],
+                    primary: Colors.white,
+                  ),
+                  onPressed: () {
+                    late PurchaseParam purchaseParam;
 
-                      if (Platform.isAndroid) {
-                        // NOTE: If you are making a subscription purchase/upgrade/downgrade, we recommend you to
-                        // verify the latest status of you your subscription by using server side receipt validation
-                        // and update the UI accordingly. The subscription purchase status shown
-                        // inside the app may not be accurate.
-                        final GooglePlayPurchaseDetails? oldSubscription =
-                            _getOldSubscription(productDetails, purchases);
+                    if (Platform.isAndroid) {
+                      // NOTE: If you are making a subscription purchase/upgrade/downgrade, we recommend you to
+                      // verify the latest status of you your subscription by using server side receipt validation
+                      // and update the UI accordingly. The subscription purchase status shown
+                      // inside the app may not be accurate.
+                      final GooglePlayPurchaseDetails? oldSubscription =
+                          _getOldSubscription(productDetails, purchases);
 
-                        purchaseParam = GooglePlayPurchaseParam(
-                            productDetails: productDetails,
-                            applicationUserName: null,
-                            changeSubscriptionParam: (oldSubscription != null)
-                                ? ChangeSubscriptionParam(
-                                    oldPurchaseDetails: oldSubscription,
-                                    prorationMode: ProrationMode
-                                        .immediateWithTimeProration,
-                                  )
-                                : null);
-                      } else {
-                        purchaseParam = PurchaseParam(
+                      purchaseParam = GooglePlayPurchaseParam(
                           productDetails: productDetails,
                           applicationUserName: null,
-                        );
-                      }
+                          changeSubscriptionParam: (oldSubscription != null)
+                              ? ChangeSubscriptionParam(
+                                  oldPurchaseDetails: oldSubscription,
+                                  prorationMode:
+                                      ProrationMode.immediateWithTimeProration,
+                                )
+                              : null);
+                    } else {
+                      purchaseParam = PurchaseParam(
+                        productDetails: productDetails,
+                        applicationUserName: null,
+                      );
+                    }
 
-                      if (productDetails.id == _kConsumableId) {
-                        _inAppPurchase.buyConsumable(
-                            purchaseParam: purchaseParam,
-                            autoConsume: _kAutoConsume || Platform.isIOS);
-                      } else {
-                        _inAppPurchase.buyNonConsumable(
-                            purchaseParam: purchaseParam);
-                      }
-                    },
-                  ));
+                    if (productDetails.id == _kConsumableId) {
+                      _inAppPurchase.buyConsumable(
+                          purchaseParam: purchaseParam,
+                          autoConsume: _kAutoConsume || Platform.isIOS);
+                    } else {
+                      _inAppPurchase.buyNonConsumable(
+                          purchaseParam: purchaseParam);
+                    }
+                  },
+                  child: Text(productDetails.price),
+                ),
+        );
       },
     ));
 
@@ -340,9 +341,9 @@
       const Divider(),
       GridView.count(
         crossAxisCount: 5,
-        children: tokens,
         shrinkWrap: true,
         padding: const EdgeInsets.all(16.0),
+        children: tokens,
       )
     ]));
   }
@@ -359,12 +360,12 @@
         mainAxisAlignment: MainAxisAlignment.end,
         children: <Widget>[
           TextButton(
-            child: const Text('Restore purchases'),
             style: TextButton.styleFrom(
               backgroundColor: Theme.of(context).primaryColor,
               primary: Colors.white,
             ),
             onPressed: () => _inAppPurchase.restorePurchases(),
+            child: const Text('Restore purchases'),
           ),
         ],
       ),
diff --git a/packages/in_app_purchase/in_app_purchase/pubspec.yaml b/packages/in_app_purchase/in_app_purchase/pubspec.yaml
index af8f5f3..d2f8752 100644
--- a/packages/in_app_purchase/in_app_purchase/pubspec.yaml
+++ b/packages/in_app_purchase/in_app_purchase/pubspec.yaml
@@ -2,7 +2,7 @@
 description: A Flutter plugin for in-app purchases. Exposes APIs for making in-app purchases through the App Store and Google Play.
 repository: https://github.com/flutter/plugins/tree/main/packages/in_app_purchase/in_app_purchase
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+in_app_purchase%22
-version: 3.0.2
+version: 3.0.3
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/in_app_purchase/in_app_purchase_android/CHANGELOG.md b/packages/in_app_purchase/in_app_purchase_android/CHANGELOG.md
index 2657d50..4b9e58c 100644
--- a/packages/in_app_purchase/in_app_purchase_android/CHANGELOG.md
+++ b/packages/in_app_purchase/in_app_purchase_android/CHANGELOG.md
@@ -1,6 +1,8 @@
-## NEXT
+## 0.2.2+4
 
 * Removes unnecessary imports.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 0.2.2+3
 
diff --git a/packages/in_app_purchase/in_app_purchase_android/example/lib/main.dart b/packages/in_app_purchase/in_app_purchase_android/example/lib/main.dart
index 939bc43..1da9435 100644
--- a/packages/in_app_purchase/in_app_purchase_android/example/lib/main.dart
+++ b/packages/in_app_purchase/in_app_purchase_android/example/lib/main.dart
@@ -37,7 +37,7 @@
 
 class _MyApp extends StatefulWidget {
   @override
-  _MyAppState createState() => _MyAppState();
+  State<_MyApp> createState() => _MyAppState();
 }
 
 class _MyAppState extends State<_MyApp> {
@@ -264,7 +264,6 @@
                     },
                     icon: const Icon(Icons.upgrade))
                 : TextButton(
-                    child: Text(productDetails.price),
                     style: TextButton.styleFrom(
                       backgroundColor: Colors.green[800],
                       primary: Colors.white,
@@ -297,6 +296,7 @@
                             purchaseParam: purchaseParam);
                       }
                     },
+                    child: Text(productDetails.price),
                   ));
       },
     ));
@@ -337,9 +337,9 @@
       const Divider(),
       GridView.count(
         crossAxisCount: 5,
-        children: tokens,
         shrinkWrap: true,
         padding: const EdgeInsets.all(16.0),
+        children: tokens,
       )
     ]));
   }
diff --git a/packages/in_app_purchase/in_app_purchase_android/pubspec.yaml b/packages/in_app_purchase/in_app_purchase_android/pubspec.yaml
index 62888e6..7de7781 100644
--- a/packages/in_app_purchase/in_app_purchase_android/pubspec.yaml
+++ b/packages/in_app_purchase/in_app_purchase_android/pubspec.yaml
@@ -2,7 +2,7 @@
 description: An implementation for the Android platform of the Flutter `in_app_purchase` plugin. This uses the Android BillingClient APIs.
 repository: https://github.com/flutter/plugins/tree/main/packages/in_app_purchase/in_app_purchase_android
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+in_app_purchase%22
-version: 0.2.2+3
+version: 0.2.2+4
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/in_app_purchase/in_app_purchase_storekit/CHANGELOG.md b/packages/in_app_purchase/in_app_purchase_storekit/CHANGELOG.md
index 403ee32..7342077 100644
--- a/packages/in_app_purchase/in_app_purchase_storekit/CHANGELOG.md
+++ b/packages/in_app_purchase/in_app_purchase_storekit/CHANGELOG.md
@@ -1,6 +1,8 @@
-## NEXT
+## 0.3.0+6
 
 * Removes unnecessary imports.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 0.3.0+5
 
diff --git a/packages/in_app_purchase/in_app_purchase_storekit/example/lib/main.dart b/packages/in_app_purchase/in_app_purchase_storekit/example/lib/main.dart
index 2ee2deb..f45a8c7 100644
--- a/packages/in_app_purchase/in_app_purchase_storekit/example/lib/main.dart
+++ b/packages/in_app_purchase/in_app_purchase_storekit/example/lib/main.dart
@@ -37,7 +37,7 @@
 
 class _MyApp extends StatefulWidget {
   @override
-  _MyAppState createState() => _MyAppState();
+  State<_MyApp> createState() => _MyAppState();
 }
 
 class _MyAppState extends State<_MyApp> {
@@ -259,7 +259,6 @@
                     },
                     icon: const Icon(Icons.upgrade))
                 : TextButton(
-                    child: Text(productDetails.price),
                     style: TextButton.styleFrom(
                       backgroundColor: Colors.green[800],
                       primary: Colors.white,
@@ -278,6 +277,7 @@
                             purchaseParam: purchaseParam);
                       }
                     },
+                    child: Text(productDetails.price),
                   ));
       },
     ));
@@ -318,9 +318,9 @@
       const Divider(),
       GridView.count(
         crossAxisCount: 5,
-        children: tokens,
         shrinkWrap: true,
         padding: const EdgeInsets.all(16.0),
+        children: tokens,
       )
     ]));
   }
@@ -337,12 +337,12 @@
         mainAxisAlignment: MainAxisAlignment.end,
         children: <Widget>[
           TextButton(
-            child: const Text('Restore purchases'),
             style: TextButton.styleFrom(
               backgroundColor: Theme.of(context).primaryColor,
               primary: Colors.white,
             ),
             onPressed: () => _iapStoreKitPlatform.restorePurchases(),
+            child: const Text('Restore purchases'),
           ),
         ],
       ),
diff --git a/packages/in_app_purchase/in_app_purchase_storekit/pubspec.yaml b/packages/in_app_purchase/in_app_purchase_storekit/pubspec.yaml
index 9693c18..24b693c 100644
--- a/packages/in_app_purchase/in_app_purchase_storekit/pubspec.yaml
+++ b/packages/in_app_purchase/in_app_purchase_storekit/pubspec.yaml
@@ -2,7 +2,7 @@
 description: An implementation for the iOS platform of the Flutter `in_app_purchase` plugin. This uses the StoreKit Framework.
 repository: https://github.com/flutter/plugins/tree/main/packages/in_app_purchase/in_app_purchase_storekit
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+in_app_purchase%22
-version: 0.3.0+5
+version: 0.3.0+6
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/ios_platform_images/CHANGELOG.md b/packages/ios_platform_images/CHANGELOG.md
index 0a3755a..cf2632f 100644
--- a/packages/ios_platform_images/CHANGELOG.md
+++ b/packages/ios_platform_images/CHANGELOG.md
@@ -1,6 +1,8 @@
-## NEXT
+## 0.2.0+6
 
 * Removes unnecessary imports.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 0.2.0+5
 
diff --git a/packages/ios_platform_images/example/lib/main.dart b/packages/ios_platform_images/example/lib/main.dart
index ecdfeb2..929814e 100644
--- a/packages/ios_platform_images/example/lib/main.dart
+++ b/packages/ios_platform_images/example/lib/main.dart
@@ -5,12 +5,15 @@
 import 'package:flutter/material.dart';
 import 'package:ios_platform_images/ios_platform_images.dart';
 
-void main() => runApp(MyApp());
+void main() => runApp(const MyApp());
 
 /// Main widget for the example app.
 class MyApp extends StatefulWidget {
+  /// Default Constructor
+  const MyApp({Key? key}) : super(key: key);
+
   @override
-  _MyAppState createState() => _MyAppState();
+  State<MyApp> createState() => _MyAppState();
 }
 
 class _MyAppState extends State<MyApp> {
diff --git a/packages/ios_platform_images/example/test/widget_test.dart b/packages/ios_platform_images/example/test/widget_test.dart
index 18e9e65..f3cd4c6 100644
--- a/packages/ios_platform_images/example/test/widget_test.dart
+++ b/packages/ios_platform_images/example/test/widget_test.dart
@@ -12,7 +12,7 @@
 void main() {
   testWidgets('Verify loads image', (WidgetTester tester) async {
     // Build our app and trigger a frame.
-    await tester.pumpWidget(MyApp());
+    await tester.pumpWidget(const MyApp());
 
     expect(
       find.byWidgetPredicate(
diff --git a/packages/ios_platform_images/pubspec.yaml b/packages/ios_platform_images/pubspec.yaml
index 7f80714..41a1775 100644
--- a/packages/ios_platform_images/pubspec.yaml
+++ b/packages/ios_platform_images/pubspec.yaml
@@ -2,7 +2,7 @@
 description: A plugin to share images between Flutter and iOS in add-to-app setups.
 repository: https://github.com/flutter/plugins/tree/main/packages/ios_platform_images
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+ios_platform_images%22
-version: 0.2.0+5
+version: 0.2.0+6
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/local_auth/local_auth/CHANGELOG.md b/packages/local_auth/local_auth/CHANGELOG.md
index 570d8ee..8a2743e 100644
--- a/packages/local_auth/local_auth/CHANGELOG.md
+++ b/packages/local_auth/local_auth/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 2.0.2
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
+
 ## 2.0.1
 
 * Restores the ability to import `error_codes.dart`.
diff --git a/packages/local_auth/local_auth/example/lib/main.dart b/packages/local_auth/local_auth/example/lib/main.dart
index 92ad7cf..cc687f5 100644
--- a/packages/local_auth/local_auth/example/lib/main.dart
+++ b/packages/local_auth/local_auth/example/lib/main.dart
@@ -11,12 +11,14 @@
 import 'package:local_auth/local_auth.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 class MyApp extends StatefulWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
-  _MyAppState createState() => _MyAppState();
+  State<MyApp> createState() => _MyAppState();
 }
 
 class _MyAppState extends State<MyApp> {
@@ -169,14 +171,14 @@
                 const Divider(height: 100),
                 Text('Can check biometrics: $_canCheckBiometrics\n'),
                 ElevatedButton(
-                  child: const Text('Check biometrics'),
                   onPressed: _checkBiometrics,
+                  child: const Text('Check biometrics'),
                 ),
                 const Divider(height: 100),
                 Text('Available biometrics: $_availableBiometrics\n'),
                 ElevatedButton(
-                  child: const Text('Get available biometrics'),
                   onPressed: _getAvailableBiometrics,
+                  child: const Text('Get available biometrics'),
                 ),
                 const Divider(height: 100),
                 Text('Current State: $_authorized\n'),
@@ -195,6 +197,7 @@
                   Column(
                     children: <Widget>[
                       ElevatedButton(
+                        onPressed: _authenticate,
                         child: Row(
                           mainAxisSize: MainAxisSize.min,
                           children: const <Widget>[
@@ -202,9 +205,9 @@
                             Icon(Icons.perm_device_information),
                           ],
                         ),
-                        onPressed: _authenticate,
                       ),
                       ElevatedButton(
+                        onPressed: _authenticateWithBiometrics,
                         child: Row(
                           mainAxisSize: MainAxisSize.min,
                           children: <Widget>[
@@ -214,7 +217,6 @@
                             const Icon(Icons.fingerprint),
                           ],
                         ),
-                        onPressed: _authenticateWithBiometrics,
                       ),
                     ],
                   ),
diff --git a/packages/local_auth/local_auth/example/lib/readme_excerpts.dart b/packages/local_auth/local_auth/example/lib/readme_excerpts.dart
index 25ddfe0..340aaef 100644
--- a/packages/local_auth/local_auth/example/lib/readme_excerpts.dart
+++ b/packages/local_auth/local_auth/example/lib/readme_excerpts.dart
@@ -24,10 +24,12 @@
 // #enddocregion CustomMessages
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 class MyApp extends StatefulWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   State<MyApp> createState() => _MyAppState();
 }
diff --git a/packages/local_auth/local_auth/pubspec.yaml b/packages/local_auth/local_auth/pubspec.yaml
index 087b849..119b8d7 100644
--- a/packages/local_auth/local_auth/pubspec.yaml
+++ b/packages/local_auth/local_auth/pubspec.yaml
@@ -3,7 +3,7 @@
   authentication via fingerprint, touch ID, face ID, passcode, pin, or pattern.
 repository: https://github.com/flutter/plugins/tree/main/packages/local_auth/local_auth
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+local_auth%22
-version: 2.0.1
+version: 2.0.2
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/local_auth/local_auth_android/CHANGELOG.md b/packages/local_auth/local_auth_android/CHANGELOG.md
index 6afcf1f..9f9bd7b 100644
--- a/packages/local_auth/local_auth_android/CHANGELOG.md
+++ b/packages/local_auth/local_auth_android/CHANGELOG.md
@@ -1,6 +1,8 @@
-## NEXT
+## 1.0.3
 
 * Removes unnecessary imports.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 1.0.2
 
diff --git a/packages/local_auth/local_auth_android/example/lib/main.dart b/packages/local_auth/local_auth_android/example/lib/main.dart
index 29b1d66..016d955 100644
--- a/packages/local_auth/local_auth_android/example/lib/main.dart
+++ b/packages/local_auth/local_auth_android/example/lib/main.dart
@@ -12,12 +12,14 @@
 import 'package:local_auth_platform_interface/local_auth_platform_interface.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 class MyApp extends StatefulWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
-  _MyAppState createState() => _MyAppState();
+  State<MyApp> createState() => _MyAppState();
 }
 
 class _MyAppState extends State<MyApp> {
@@ -174,14 +176,14 @@
                 Text(
                     'Device supports biometrics: $_deviceSupportsBiometrics\n'),
                 ElevatedButton(
-                  child: const Text('Check biometrics'),
                   onPressed: _checkBiometrics,
+                  child: const Text('Check biometrics'),
                 ),
                 const Divider(height: 100),
                 Text('Enrolled biometrics: $_enrolledBiometrics\n'),
                 ElevatedButton(
-                  child: const Text('Get enrolled biometrics'),
                   onPressed: _getEnrolledBiometrics,
+                  child: const Text('Get enrolled biometrics'),
                 ),
                 const Divider(height: 100),
                 Text('Current State: $_authorized\n'),
@@ -200,6 +202,7 @@
                   Column(
                     children: <Widget>[
                       ElevatedButton(
+                        onPressed: _authenticate,
                         child: Row(
                           mainAxisSize: MainAxisSize.min,
                           children: const <Widget>[
@@ -207,9 +210,9 @@
                             Icon(Icons.perm_device_information),
                           ],
                         ),
-                        onPressed: _authenticate,
                       ),
                       ElevatedButton(
+                        onPressed: _authenticateWithBiometrics,
                         child: Row(
                           mainAxisSize: MainAxisSize.min,
                           children: <Widget>[
@@ -219,7 +222,6 @@
                             const Icon(Icons.fingerprint),
                           ],
                         ),
-                        onPressed: _authenticateWithBiometrics,
                       ),
                     ],
                   ),
diff --git a/packages/local_auth/local_auth_android/pubspec.yaml b/packages/local_auth/local_auth_android/pubspec.yaml
index aad0b9b..cdd4e82 100644
--- a/packages/local_auth/local_auth_android/pubspec.yaml
+++ b/packages/local_auth/local_auth_android/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Android implementation of the local_auth plugin.
 repository: https://github.com/flutter/plugins/tree/master/packages/local_auth/local_auth_android
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+local_auth%22
-version: 1.0.2
+version: 1.0.3
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/local_auth/local_auth_ios/CHANGELOG.md b/packages/local_auth/local_auth_ios/CHANGELOG.md
index ca6ac43..2237cbe 100644
--- a/packages/local_auth/local_auth_ios/CHANGELOG.md
+++ b/packages/local_auth/local_auth_ios/CHANGELOG.md
@@ -1,6 +1,8 @@
-## NEXT
+## 1.0.5
 
 * Removes unnecessary imports.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 1.0.4
 
diff --git a/packages/local_auth/local_auth_ios/example/lib/main.dart b/packages/local_auth/local_auth_ios/example/lib/main.dart
index a8bf23b..479a96b 100644
--- a/packages/local_auth/local_auth_ios/example/lib/main.dart
+++ b/packages/local_auth/local_auth_ios/example/lib/main.dart
@@ -12,12 +12,14 @@
 import 'package:local_auth_platform_interface/local_auth_platform_interface.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 class MyApp extends StatefulWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
-  _MyAppState createState() => _MyAppState();
+  State<MyApp> createState() => _MyAppState();
 }
 
 class _MyAppState extends State<MyApp> {
@@ -173,14 +175,14 @@
                 const Divider(height: 100),
                 Text('Device supports biometrics: $_canCheckBiometrics\n'),
                 ElevatedButton(
-                  child: const Text('Check biometrics'),
                   onPressed: _checkBiometrics,
+                  child: const Text('Check biometrics'),
                 ),
                 const Divider(height: 100),
                 Text('Enrolled biometrics: $_enrolledBiometrics\n'),
                 ElevatedButton(
-                  child: const Text('Get enrolled biometrics'),
                   onPressed: _getEnrolledBiometrics,
+                  child: const Text('Get enrolled biometrics'),
                 ),
                 const Divider(height: 100),
                 Text('Current State: $_authorized\n'),
@@ -199,6 +201,7 @@
                   Column(
                     children: <Widget>[
                       ElevatedButton(
+                        onPressed: _authenticate,
                         child: Row(
                           mainAxisSize: MainAxisSize.min,
                           children: const <Widget>[
@@ -206,9 +209,9 @@
                             Icon(Icons.perm_device_information),
                           ],
                         ),
-                        onPressed: _authenticate,
                       ),
                       ElevatedButton(
+                        onPressed: _authenticateWithBiometrics,
                         child: Row(
                           mainAxisSize: MainAxisSize.min,
                           children: <Widget>[
@@ -218,7 +221,6 @@
                             const Icon(Icons.fingerprint),
                           ],
                         ),
-                        onPressed: _authenticateWithBiometrics,
                       ),
                     ],
                   ),
diff --git a/packages/local_auth/local_auth_ios/pubspec.yaml b/packages/local_auth/local_auth_ios/pubspec.yaml
index 77ab74d..dded42b 100644
--- a/packages/local_auth/local_auth_ios/pubspec.yaml
+++ b/packages/local_auth/local_auth_ios/pubspec.yaml
@@ -2,7 +2,7 @@
 description: iOS implementation of the local_auth plugin.
 repository: https://github.com/flutter/plugins/tree/master/packages/local_auth/local_auth_ios
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+local_auth%22
-version: 1.0.4
+version: 1.0.5
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/path_provider/path_provider/CHANGELOG.md b/packages/path_provider/path_provider/CHANGELOG.md
index a26a890..9900216 100644
--- a/packages/path_provider/path_provider/CHANGELOG.md
+++ b/packages/path_provider/path_provider/CHANGELOG.md
@@ -1,7 +1,9 @@
-## NEXT
+## 2.0.10
 
 * Removes unnecessary imports.
 * Adds OS version support information to README.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 2.0.9
 
diff --git a/packages/path_provider/path_provider/example/lib/main.dart b/packages/path_provider/path_provider/example/lib/main.dart
index 90c2ccb..cb9c2eb 100644
--- a/packages/path_provider/path_provider/example/lib/main.dart
+++ b/packages/path_provider/path_provider/example/lib/main.dart
@@ -10,10 +10,12 @@
 import 'package:path_provider/path_provider.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 class MyApp extends StatelessWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     return MaterialApp(
@@ -31,7 +33,7 @@
   final String title;
 
   @override
-  _MyHomePageState createState() => _MyHomePageState();
+  State<MyHomePage> createState() => _MyHomePageState();
 }
 
 class _MyHomePageState extends State<MyHomePage> {
@@ -138,10 +140,10 @@
                 Padding(
                   padding: const EdgeInsets.all(16.0),
                   child: ElevatedButton(
+                    onPressed: _requestTempDirectory,
                     child: const Text(
                       'Get Temporary Directory',
                     ),
-                    onPressed: _requestTempDirectory,
                   ),
                 ),
                 FutureBuilder<Directory?>(
@@ -155,10 +157,10 @@
                 Padding(
                   padding: const EdgeInsets.all(16.0),
                   child: ElevatedButton(
+                    onPressed: _requestAppDocumentsDirectory,
                     child: const Text(
                       'Get Application Documents Directory',
                     ),
-                    onPressed: _requestAppDocumentsDirectory,
                   ),
                 ),
                 FutureBuilder<Directory?>(
@@ -172,10 +174,10 @@
                 Padding(
                   padding: const EdgeInsets.all(16.0),
                   child: ElevatedButton(
+                    onPressed: _requestAppSupportDirectory,
                     child: const Text(
                       'Get Application Support Directory',
                     ),
-                    onPressed: _requestAppSupportDirectory,
                   ),
                 ),
                 FutureBuilder<Directory?>(
@@ -189,13 +191,13 @@
                 Padding(
                   padding: const EdgeInsets.all(16.0),
                   child: ElevatedButton(
+                    onPressed:
+                        Platform.isAndroid ? null : _requestAppLibraryDirectory,
                     child: Text(
                       Platform.isAndroid
                           ? 'Application Library Directory unavailable'
                           : 'Get Application Library Directory',
                     ),
-                    onPressed:
-                        Platform.isAndroid ? null : _requestAppLibraryDirectory,
                   ),
                 ),
                 FutureBuilder<Directory?>(
@@ -209,14 +211,14 @@
                 Padding(
                   padding: const EdgeInsets.all(16.0),
                   child: ElevatedButton(
+                    onPressed: !Platform.isAndroid
+                        ? null
+                        : _requestExternalStorageDirectory,
                     child: Text(
                       !Platform.isAndroid
                           ? 'External storage is unavailable'
                           : 'Get External Storage Directory',
                     ),
-                    onPressed: !Platform.isAndroid
-                        ? null
-                        : _requestExternalStorageDirectory,
                   ),
                 ),
                 FutureBuilder<Directory?>(
@@ -230,11 +232,6 @@
                 Padding(
                   padding: const EdgeInsets.all(16.0),
                   child: ElevatedButton(
-                    child: Text(
-                      !Platform.isAndroid
-                          ? 'External directories are unavailable'
-                          : 'Get External Storage Directories',
-                    ),
                     onPressed: !Platform.isAndroid
                         ? null
                         : () {
@@ -242,6 +239,11 @@
                               StorageDirectory.music,
                             );
                           },
+                    child: Text(
+                      !Platform.isAndroid
+                          ? 'External directories are unavailable'
+                          : 'Get External Storage Directories',
+                    ),
                   ),
                 ),
                 FutureBuilder<List<Directory>?>(
@@ -255,14 +257,14 @@
                 Padding(
                   padding: const EdgeInsets.all(16.0),
                   child: ElevatedButton(
+                    onPressed: !Platform.isAndroid
+                        ? null
+                        : _requestExternalCacheDirectories,
                     child: Text(
                       !Platform.isAndroid
                           ? 'External directories are unavailable'
                           : 'Get External Cache Directories',
                     ),
-                    onPressed: !Platform.isAndroid
-                        ? null
-                        : _requestExternalCacheDirectories,
                   ),
                 ),
                 FutureBuilder<List<Directory>?>(
@@ -276,14 +278,14 @@
                 Padding(
                   padding: const EdgeInsets.all(16.0),
                   child: ElevatedButton(
+                    onPressed: Platform.isAndroid || Platform.isIOS
+                        ? null
+                        : _requestDownloadsDirectory,
                     child: Text(
                       Platform.isAndroid || Platform.isIOS
                           ? 'Downloads directory is unavailable'
                           : 'Get Downloads Directory',
                     ),
-                    onPressed: Platform.isAndroid || Platform.isIOS
-                        ? null
-                        : _requestDownloadsDirectory,
                   ),
                 ),
                 FutureBuilder<Directory?>(
diff --git a/packages/path_provider/path_provider/pubspec.yaml b/packages/path_provider/path_provider/pubspec.yaml
index 30ddfdc..6ca8325 100644
--- a/packages/path_provider/path_provider/pubspec.yaml
+++ b/packages/path_provider/path_provider/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Flutter plugin for getting commonly used locations on host platform file systems, such as the temp and app data directories.
 repository: https://github.com/flutter/plugins/tree/main/packages/path_provider/path_provider
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+path_provider%22
-version: 2.0.9
+version: 2.0.10
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/path_provider/path_provider_android/CHANGELOG.md b/packages/path_provider/path_provider_android/CHANGELOG.md
index 31f8c81..4b15e26 100644
--- a/packages/path_provider/path_provider_android/CHANGELOG.md
+++ b/packages/path_provider/path_provider_android/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 2.0.14
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
+
 ## 2.0.13
 
 * Fixes typing build warning.
diff --git a/packages/path_provider/path_provider_android/example/lib/main.dart b/packages/path_provider/path_provider_android/example/lib/main.dart
index 6e04f86..fc9424a 100644
--- a/packages/path_provider/path_provider_android/example/lib/main.dart
+++ b/packages/path_provider/path_provider_android/example/lib/main.dart
@@ -8,10 +8,12 @@
 import 'package:path_provider_platform_interface/path_provider_platform_interface.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 class MyApp extends StatelessWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     return MaterialApp(
@@ -29,7 +31,7 @@
   final String title;
 
   @override
-  _MyHomePageState createState() => _MyHomePageState();
+  State<MyHomePage> createState() => _MyHomePageState();
 }
 
 class _MyHomePageState extends State<MyHomePage> {
@@ -121,8 +123,8 @@
             Padding(
               padding: const EdgeInsets.all(16.0),
               child: ElevatedButton(
-                child: const Text('Get Temporary Directory'),
                 onPressed: _requestTempDirectory,
+                child: const Text('Get Temporary Directory'),
               ),
             ),
             FutureBuilder<String?>(
@@ -130,8 +132,8 @@
             Padding(
               padding: const EdgeInsets.all(16.0),
               child: ElevatedButton(
-                child: const Text('Get Application Documents Directory'),
                 onPressed: _requestAppDocumentsDirectory,
+                child: const Text('Get Application Documents Directory'),
               ),
             ),
             FutureBuilder<String?>(
@@ -139,8 +141,8 @@
             Padding(
               padding: const EdgeInsets.all(16.0),
               child: ElevatedButton(
-                child: const Text('Get Application Support Directory'),
                 onPressed: _requestAppSupportDirectory,
+                child: const Text('Get Application Support Directory'),
               ),
             ),
             FutureBuilder<String?>(
@@ -148,8 +150,8 @@
             Padding(
               padding: const EdgeInsets.all(16.0),
               child: ElevatedButton(
-                child: const Text('Get External Storage Directory'),
                 onPressed: _requestExternalStorageDirectory,
+                child: const Text('Get External Storage Directory'),
               ),
             ),
             FutureBuilder<String?>(
@@ -174,8 +176,8 @@
               Padding(
                 padding: const EdgeInsets.all(16.0),
                 child: ElevatedButton(
-                  child: const Text('Get External Cache Directories'),
                   onPressed: _requestExternalCacheDirectories,
+                  child: const Text('Get External Cache Directories'),
                 ),
               ),
             ]),
diff --git a/packages/path_provider/path_provider_android/pubspec.yaml b/packages/path_provider/path_provider_android/pubspec.yaml
index 93ed984..f1dc92a 100644
--- a/packages/path_provider/path_provider_android/pubspec.yaml
+++ b/packages/path_provider/path_provider_android/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Android implementation of the path_provider plugin.
 repository: https://github.com/flutter/plugins/tree/main/packages/path_provider/path_provider_android
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+path_provider%22
-version: 2.0.13
+version: 2.0.14
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/path_provider/path_provider_ios/CHANGELOG.md b/packages/path_provider/path_provider_ios/CHANGELOG.md
index 543af77..1940f5c 100644
--- a/packages/path_provider/path_provider_ios/CHANGELOG.md
+++ b/packages/path_provider/path_provider_ios/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 2.0.9
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
+
 ## 2.0.8
 
 * Switches to a package-internal implementation of the platform interface.
diff --git a/packages/path_provider/path_provider_ios/example/lib/main.dart b/packages/path_provider/path_provider_ios/example/lib/main.dart
index 8c8d541..d7140b7 100644
--- a/packages/path_provider/path_provider_ios/example/lib/main.dart
+++ b/packages/path_provider/path_provider_ios/example/lib/main.dart
@@ -8,10 +8,12 @@
 import 'package:path_provider_platform_interface/path_provider_platform_interface.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 class MyApp extends StatelessWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     return MaterialApp(
@@ -29,7 +31,7 @@
   final String title;
 
   @override
-  _MyHomePageState createState() => _MyHomePageState();
+  State<MyHomePage> createState() => _MyHomePageState();
 }
 
 class _MyHomePageState extends State<MyHomePage> {
@@ -90,8 +92,8 @@
             Padding(
               padding: const EdgeInsets.all(16.0),
               child: ElevatedButton(
-                child: const Text('Get Temporary Directory'),
                 onPressed: _requestTempDirectory,
+                child: const Text('Get Temporary Directory'),
               ),
             ),
             FutureBuilder<String?>(
@@ -99,8 +101,8 @@
             Padding(
               padding: const EdgeInsets.all(16.0),
               child: ElevatedButton(
-                child: const Text('Get Application Documents Directory'),
                 onPressed: _requestAppDocumentsDirectory,
+                child: const Text('Get Application Documents Directory'),
               ),
             ),
             FutureBuilder<String?>(
@@ -108,8 +110,8 @@
             Padding(
               padding: const EdgeInsets.all(16.0),
               child: ElevatedButton(
-                child: const Text('Get Application Support Directory'),
                 onPressed: _requestAppSupportDirectory,
+                child: const Text('Get Application Support Directory'),
               ),
             ),
             FutureBuilder<String?>(
@@ -117,8 +119,8 @@
             Padding(
               padding: const EdgeInsets.all(16.0),
               child: ElevatedButton(
-                child: const Text('Get Application Library Directory'),
                 onPressed: _requestAppLibraryDirectory,
+                child: const Text('Get Application Library Directory'),
               ),
             ),
             FutureBuilder<String?>(
diff --git a/packages/path_provider/path_provider_ios/pubspec.yaml b/packages/path_provider/path_provider_ios/pubspec.yaml
index 282f8e4..d6c7de1 100644
--- a/packages/path_provider/path_provider_ios/pubspec.yaml
+++ b/packages/path_provider/path_provider_ios/pubspec.yaml
@@ -2,7 +2,7 @@
 description: iOS implementation of the path_provider plugin.
 repository: https://github.com/flutter/plugins/tree/main/packages/path_provider/path_provider_ios
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+path_provider%22
-version: 2.0.8
+version: 2.0.9
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/path_provider/path_provider_linux/CHANGELOG.md b/packages/path_provider/path_provider_linux/CHANGELOG.md
index 55235c3..c9c4bb3 100644
--- a/packages/path_provider/path_provider_linux/CHANGELOG.md
+++ b/packages/path_provider/path_provider_linux/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 2.1.6
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
+
 ## 2.1.5
 
 * Removes dependency on `meta`.
diff --git a/packages/path_provider/path_provider_linux/example/lib/main.dart b/packages/path_provider/path_provider_linux/example/lib/main.dart
index d365e6b..1c7c7e8 100644
--- a/packages/path_provider/path_provider_linux/example/lib/main.dart
+++ b/packages/path_provider/path_provider_linux/example/lib/main.dart
@@ -7,13 +7,16 @@
 import 'package:path_provider_linux/path_provider_linux.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 /// Sample app
 class MyApp extends StatefulWidget {
+  /// Default Constructor
+  const MyApp({Key? key}) : super(key: key);
+
   @override
-  _MyAppState createState() => _MyAppState();
+  State<MyApp> createState() => _MyAppState();
 }
 
 class _MyAppState extends State<MyApp> {
diff --git a/packages/path_provider/path_provider_linux/pubspec.yaml b/packages/path_provider/path_provider_linux/pubspec.yaml
index 91304fc..16438a3 100644
--- a/packages/path_provider/path_provider_linux/pubspec.yaml
+++ b/packages/path_provider/path_provider_linux/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Linux implementation of the path_provider plugin
 repository: https://github.com/flutter/plugins/tree/main/packages/path_provider/path_provider_linux
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+path_provider%22
-version: 2.1.5
+version: 2.1.6
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/path_provider/path_provider_macos/CHANGELOG.md b/packages/path_provider/path_provider_macos/CHANGELOG.md
index 047792f..c59ba97 100644
--- a/packages/path_provider/path_provider_macos/CHANGELOG.md
+++ b/packages/path_provider/path_provider_macos/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 2.0.6
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
+
 ## 2.0.5
 
 * Removes dependency on `meta`.
diff --git a/packages/path_provider/path_provider_macos/example/lib/main.dart b/packages/path_provider/path_provider_macos/example/lib/main.dart
index 67a0eb3..13a6fad 100644
--- a/packages/path_provider/path_provider_macos/example/lib/main.dart
+++ b/packages/path_provider/path_provider_macos/example/lib/main.dart
@@ -8,13 +8,15 @@
 import 'package:path_provider_platform_interface/path_provider_platform_interface.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 /// Sample app
 class MyApp extends StatefulWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
-  _MyAppState createState() => _MyAppState();
+  State<MyApp> createState() => _MyAppState();
 }
 
 class _MyAppState extends State<MyApp> {
diff --git a/packages/path_provider/path_provider_macos/pubspec.yaml b/packages/path_provider/path_provider_macos/pubspec.yaml
index 2451b6d..444165b 100644
--- a/packages/path_provider/path_provider_macos/pubspec.yaml
+++ b/packages/path_provider/path_provider_macos/pubspec.yaml
@@ -2,7 +2,7 @@
 description: macOS implementation of the path_provider plugin
 repository: https://github.com/flutter/plugins/tree/main/packages/path_provider/path_provider_macos
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+path_provider%22
-version: 2.0.5
+version: 2.0.6
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/path_provider/path_provider_windows/CHANGELOG.md b/packages/path_provider/path_provider_windows/CHANGELOG.md
index cd33e85..014b6b3 100644
--- a/packages/path_provider/path_provider_windows/CHANGELOG.md
+++ b/packages/path_provider/path_provider_windows/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 2.0.6
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
+
 ## 2.0.5
 
 * Removes dependency on `meta`.
diff --git a/packages/path_provider/path_provider_windows/example/lib/main.dart b/packages/path_provider/path_provider_windows/example/lib/main.dart
index 509292b..4c63d24 100644
--- a/packages/path_provider/path_provider_windows/example/lib/main.dart
+++ b/packages/path_provider/path_provider_windows/example/lib/main.dart
@@ -8,13 +8,15 @@
 import 'package:path_provider_windows/path_provider_windows.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 /// Sample app
 class MyApp extends StatefulWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
-  _MyAppState createState() => _MyAppState();
+  State<MyApp> createState() => _MyAppState();
 }
 
 class _MyAppState extends State<MyApp> {
diff --git a/packages/path_provider/path_provider_windows/pubspec.yaml b/packages/path_provider/path_provider_windows/pubspec.yaml
index 873fa0a..49afdd6 100644
--- a/packages/path_provider/path_provider_windows/pubspec.yaml
+++ b/packages/path_provider/path_provider_windows/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Windows implementation of the path_provider plugin
 repository: https://github.com/flutter/plugins/tree/main/packages/path_provider/path_provider_windows
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+path_provider%22
-version: 2.0.5
+version: 2.0.6
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/quick_actions/quick_actions/CHANGELOG.md b/packages/quick_actions/quick_actions/CHANGELOG.md
index c30d705..73540a8 100644
--- a/packages/quick_actions/quick_actions/CHANGELOG.md
+++ b/packages/quick_actions/quick_actions/CHANGELOG.md
@@ -1,8 +1,10 @@
-## NEXT
+## 0.6.0+11
 
 * Removes unnecessary imports.
 * Updates minimum Flutter version to 2.8.
 * Adds OS version support information to README.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 0.6.0+10
 
diff --git a/packages/quick_actions/quick_actions/example/lib/main.dart b/packages/quick_actions/quick_actions/example/lib/main.dart
index 1ce6f51..cafbf0c 100644
--- a/packages/quick_actions/quick_actions/example/lib/main.dart
+++ b/packages/quick_actions/quick_actions/example/lib/main.dart
@@ -8,10 +8,12 @@
 import 'package:quick_actions/quick_actions.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 class MyApp extends StatelessWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     return MaterialApp(
@@ -28,7 +30,7 @@
   const MyHomePage({Key? key}) : super(key: key);
 
   @override
-  _MyHomePageState createState() => _MyHomePageState();
+  State<MyHomePage> createState() => _MyHomePageState();
 }
 
 class _MyHomePageState extends State<MyHomePage> {
diff --git a/packages/quick_actions/quick_actions/pubspec.yaml b/packages/quick_actions/quick_actions/pubspec.yaml
index 8ef2d3a..37e8dbe 100644
--- a/packages/quick_actions/quick_actions/pubspec.yaml
+++ b/packages/quick_actions/quick_actions/pubspec.yaml
@@ -3,7 +3,7 @@
   Quick Actions on iOS and App Shortcuts on Android.
 repository: https://github.com/flutter/plugins/tree/main/packages/quick_actions/quick_actions
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+quick_actions%22
-version: 0.6.0+10
+version: 0.6.0+11
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/quick_actions/quick_actions_android/CHANGELOG.md b/packages/quick_actions/quick_actions_android/CHANGELOG.md
index 98e8cf5..56accc9 100644
--- a/packages/quick_actions/quick_actions_android/CHANGELOG.md
+++ b/packages/quick_actions/quick_actions_android/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 0.6.0+10
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
+
 ## 0.6.0+9
 
 * Switches to a package-internal implementation of the platform interface.
\ No newline at end of file
diff --git a/packages/quick_actions/quick_actions_android/example/lib/main.dart b/packages/quick_actions/quick_actions_android/example/lib/main.dart
index 06f1410..d8b7832 100644
--- a/packages/quick_actions/quick_actions_android/example/lib/main.dart
+++ b/packages/quick_actions/quick_actions_android/example/lib/main.dart
@@ -8,10 +8,12 @@
 import 'package:quick_actions_android/quick_actions_android.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 class MyApp extends StatelessWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     return MaterialApp(
@@ -28,7 +30,7 @@
   const MyHomePage({Key? key}) : super(key: key);
 
   @override
-  _MyHomePageState createState() => _MyHomePageState();
+  State<MyHomePage> createState() => _MyHomePageState();
 }
 
 class _MyHomePageState extends State<MyHomePage> {
diff --git a/packages/quick_actions/quick_actions_android/pubspec.yaml b/packages/quick_actions/quick_actions_android/pubspec.yaml
index cf9971d..4ddbc79 100644
--- a/packages/quick_actions/quick_actions_android/pubspec.yaml
+++ b/packages/quick_actions/quick_actions_android/pubspec.yaml
@@ -2,7 +2,7 @@
 description: An implementation for the Android platform of the Flutter `quick_actions` plugin.
 repository: https://github.com/flutter/plugins/tree/main/packages/quick_actions/quick_actions_android
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+in_app_purchase%22
-version: 0.6.0+9
+version: 0.6.0+10
 
 environment:
   sdk: ">=2.15.0 <3.0.0"
diff --git a/packages/quick_actions/quick_actions_ios/CHANGELOG.md b/packages/quick_actions/quick_actions_ios/CHANGELOG.md
index d48afbd..56accc9 100644
--- a/packages/quick_actions/quick_actions_ios/CHANGELOG.md
+++ b/packages/quick_actions/quick_actions_ios/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 0.6.0+10
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 0.6.0+9
 
diff --git a/packages/quick_actions/quick_actions_ios/example/lib/main.dart b/packages/quick_actions/quick_actions_ios/example/lib/main.dart
index 5173d95..008917b 100644
--- a/packages/quick_actions/quick_actions_ios/example/lib/main.dart
+++ b/packages/quick_actions/quick_actions_ios/example/lib/main.dart
@@ -8,10 +8,12 @@
 import 'package:quick_actions_ios/quick_actions_ios.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 class MyApp extends StatelessWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     return MaterialApp(
@@ -28,7 +30,7 @@
   const MyHomePage({Key? key}) : super(key: key);
 
   @override
-  _MyHomePageState createState() => _MyHomePageState();
+  State<MyHomePage> createState() => _MyHomePageState();
 }
 
 class _MyHomePageState extends State<MyHomePage> {
diff --git a/packages/quick_actions/quick_actions_ios/pubspec.yaml b/packages/quick_actions/quick_actions_ios/pubspec.yaml
index 26644ba..47748b9 100644
--- a/packages/quick_actions/quick_actions_ios/pubspec.yaml
+++ b/packages/quick_actions/quick_actions_ios/pubspec.yaml
@@ -2,7 +2,7 @@
 description: An implementation for the iOS platform of the Flutter `quick_actions` plugin.
 repository: https://github.com/flutter/plugins/tree/main/packages/quick_actions/quick_actions_ios
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+in_app_purchase%22
-version: 0.6.0+9
+version: 0.6.0+10
 
 environment:
   sdk: ">=2.15.0 <3.0.0"
diff --git a/packages/shared_preferences/shared_preferences/CHANGELOG.md b/packages/shared_preferences/shared_preferences/CHANGELOG.md
index 84566e2..22c39aa 100644
--- a/packages/shared_preferences/shared_preferences/CHANGELOG.md
+++ b/packages/shared_preferences/shared_preferences/CHANGELOG.md
@@ -1,6 +1,8 @@
-## NEXT
+## 2.0.14
 
 * Adds OS version support information to README.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 2.0.13
 
diff --git a/packages/shared_preferences/shared_preferences/example/lib/main.dart b/packages/shared_preferences/shared_preferences/example/lib/main.dart
index 43f3c78..a2e72b4 100644
--- a/packages/shared_preferences/shared_preferences/example/lib/main.dart
+++ b/packages/shared_preferences/shared_preferences/example/lib/main.dart
@@ -10,10 +10,12 @@
 import 'package:shared_preferences/shared_preferences.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 class MyApp extends StatelessWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     return const MaterialApp(
diff --git a/packages/shared_preferences/shared_preferences/pubspec.yaml b/packages/shared_preferences/shared_preferences/pubspec.yaml
index 39b48ef..4218095 100644
--- a/packages/shared_preferences/shared_preferences/pubspec.yaml
+++ b/packages/shared_preferences/shared_preferences/pubspec.yaml
@@ -3,7 +3,7 @@
   Wraps NSUserDefaults on iOS and SharedPreferences on Android.
 repository: https://github.com/flutter/plugins/tree/main/packages/shared_preferences/shared_preferences
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+shared_preferences%22
-version: 2.0.13
+version: 2.0.14
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/shared_preferences/shared_preferences_android/CHANGELOG.md b/packages/shared_preferences/shared_preferences_android/CHANGELOG.md
index 5321e86..51e99ec 100644
--- a/packages/shared_preferences/shared_preferences_android/CHANGELOG.md
+++ b/packages/shared_preferences/shared_preferences_android/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 2.0.12
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
+
 ## 2.0.11
 
 * Switches to an in-package method channel implementation.
diff --git a/packages/shared_preferences/shared_preferences_android/example/lib/main.dart b/packages/shared_preferences/shared_preferences_android/example/lib/main.dart
index 06ee943..bb513b0 100644
--- a/packages/shared_preferences/shared_preferences_android/example/lib/main.dart
+++ b/packages/shared_preferences/shared_preferences_android/example/lib/main.dart
@@ -8,10 +8,12 @@
 import 'package:shared_preferences_platform_interface/shared_preferences_platform_interface.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 class MyApp extends StatelessWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     return const MaterialApp(
diff --git a/packages/shared_preferences/shared_preferences_android/pubspec.yaml b/packages/shared_preferences/shared_preferences_android/pubspec.yaml
index 7eb180f..2d8cc88 100644
--- a/packages/shared_preferences/shared_preferences_android/pubspec.yaml
+++ b/packages/shared_preferences/shared_preferences_android/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Android implementation of the shared_preferences plugin
 repository: https://github.com/flutter/plugins/tree/main/packages/shared_preferences/shared_preferences_android
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+shared_preferences%22
-version: 2.0.11
+version: 2.0.12
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/shared_preferences/shared_preferences_ios/CHANGELOG.md b/packages/shared_preferences/shared_preferences_ios/CHANGELOG.md
index a5cc1d3..29ade8d 100644
--- a/packages/shared_preferences/shared_preferences_ios/CHANGELOG.md
+++ b/packages/shared_preferences/shared_preferences_ios/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 2.1.1
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
+
 ## 2.1.0
 
 * Upgrades to using Pigeon.
diff --git a/packages/shared_preferences/shared_preferences_ios/example/lib/main.dart b/packages/shared_preferences/shared_preferences_ios/example/lib/main.dart
index 06ee943..bb513b0 100644
--- a/packages/shared_preferences/shared_preferences_ios/example/lib/main.dart
+++ b/packages/shared_preferences/shared_preferences_ios/example/lib/main.dart
@@ -8,10 +8,12 @@
 import 'package:shared_preferences_platform_interface/shared_preferences_platform_interface.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 class MyApp extends StatelessWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     return const MaterialApp(
diff --git a/packages/shared_preferences/shared_preferences_ios/pubspec.yaml b/packages/shared_preferences/shared_preferences_ios/pubspec.yaml
index 33bf5ba..a8bde2e 100644
--- a/packages/shared_preferences/shared_preferences_ios/pubspec.yaml
+++ b/packages/shared_preferences/shared_preferences_ios/pubspec.yaml
@@ -2,7 +2,7 @@
 description: iOS implementation of the shared_preferences plugin
 repository: https://github.com/flutter/plugins/tree/main/packages/shared_preferences/shared_preferences_ios
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+shared_preferences%22
-version: 2.1.0
+version: 2.1.1
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/shared_preferences/shared_preferences_linux/CHANGELOG.md b/packages/shared_preferences/shared_preferences_linux/CHANGELOG.md
index 34dd631..f0cb832 100644
--- a/packages/shared_preferences/shared_preferences_linux/CHANGELOG.md
+++ b/packages/shared_preferences/shared_preferences_linux/CHANGELOG.md
@@ -1,6 +1,8 @@
-## NEXT
+## 2.1.1
 
 * Removes unnecessary imports.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 2.1.0
 
diff --git a/packages/shared_preferences/shared_preferences_linux/example/lib/main.dart b/packages/shared_preferences/shared_preferences_linux/example/lib/main.dart
index 4b71c7e..d51be33 100644
--- a/packages/shared_preferences/shared_preferences_linux/example/lib/main.dart
+++ b/packages/shared_preferences/shared_preferences_linux/example/lib/main.dart
@@ -10,10 +10,12 @@
 import 'package:shared_preferences_linux/shared_preferences_linux.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 class MyApp extends StatelessWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     return const MaterialApp(
diff --git a/packages/shared_preferences/shared_preferences_linux/pubspec.yaml b/packages/shared_preferences/shared_preferences_linux/pubspec.yaml
index 8ab692a..8f3ce17 100644
--- a/packages/shared_preferences/shared_preferences_linux/pubspec.yaml
+++ b/packages/shared_preferences/shared_preferences_linux/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Linux implementation of the shared_preferences plugin
 repository: https://github.com/flutter/plugins/tree/main/packages/shared_preferences/shared_preferences_linux
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+shared_preferences%22
-version: 2.1.0
+version: 2.1.1
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/shared_preferences/shared_preferences_macos/CHANGELOG.md b/packages/shared_preferences/shared_preferences_macos/CHANGELOG.md
index 0f194de..8ba116a 100644
--- a/packages/shared_preferences/shared_preferences_macos/CHANGELOG.md
+++ b/packages/shared_preferences/shared_preferences_macos/CHANGELOG.md
@@ -1,6 +1,8 @@
-## NEXT
+## 2.0.4
 
 * Removes unnecessary imports.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 2.0.3
 
diff --git a/packages/shared_preferences/shared_preferences_macos/example/lib/main.dart b/packages/shared_preferences/shared_preferences_macos/example/lib/main.dart
index 349e9c4..e6bbe59 100644
--- a/packages/shared_preferences/shared_preferences_macos/example/lib/main.dart
+++ b/packages/shared_preferences/shared_preferences_macos/example/lib/main.dart
@@ -10,10 +10,12 @@
 import 'package:shared_preferences_platform_interface/shared_preferences_platform_interface.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 class MyApp extends StatelessWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     return const MaterialApp(
diff --git a/packages/shared_preferences/shared_preferences_macos/pubspec.yaml b/packages/shared_preferences/shared_preferences_macos/pubspec.yaml
index 0873696..615d0b0 100644
--- a/packages/shared_preferences/shared_preferences_macos/pubspec.yaml
+++ b/packages/shared_preferences/shared_preferences_macos/pubspec.yaml
@@ -2,7 +2,7 @@
 description: macOS implementation of the shared_preferences plugin.
 repository: https://github.com/flutter/plugins/tree/main/packages/shared_preferences/shared_preferences_macos
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+shared_preferences%22
-version: 2.0.3
+version: 2.0.4
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/shared_preferences/shared_preferences_web/CHANGELOG.md b/packages/shared_preferences/shared_preferences_web/CHANGELOG.md
index 2a6ffa2..9ea2490 100644
--- a/packages/shared_preferences/shared_preferences_web/CHANGELOG.md
+++ b/packages/shared_preferences/shared_preferences_web/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 2.0.4
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
+
 ## 2.0.3
 
 * Fixes newly enabled analyzer options.
diff --git a/packages/shared_preferences/shared_preferences_web/example/lib/main.dart b/packages/shared_preferences/shared_preferences_web/example/lib/main.dart
index 341913a..8742295 100644
--- a/packages/shared_preferences/shared_preferences_web/example/lib/main.dart
+++ b/packages/shared_preferences/shared_preferences_web/example/lib/main.dart
@@ -5,13 +5,16 @@
 import 'package:flutter/material.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 /// App for testing
 class MyApp extends StatefulWidget {
+  /// Default Constructor
+  const MyApp({Key? key}) : super(key: key);
+
   @override
-  _MyAppState createState() => _MyAppState();
+  State<MyApp> createState() => _MyAppState();
 }
 
 class _MyAppState extends State<MyApp> {
diff --git a/packages/shared_preferences/shared_preferences_web/pubspec.yaml b/packages/shared_preferences/shared_preferences_web/pubspec.yaml
index 232c87c..9ff76d2 100644
--- a/packages/shared_preferences/shared_preferences_web/pubspec.yaml
+++ b/packages/shared_preferences/shared_preferences_web/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Web platform implementation of shared_preferences
 repository: https://github.com/flutter/plugins/tree/main/packages/shared_preferences/shared_preferences_web
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+shared_preferences%22
-version: 2.0.3
+version: 2.0.4
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/shared_preferences/shared_preferences_windows/CHANGELOG.md b/packages/shared_preferences/shared_preferences_windows/CHANGELOG.md
index 6c96681..f79f9e3 100644
--- a/packages/shared_preferences/shared_preferences_windows/CHANGELOG.md
+++ b/packages/shared_preferences/shared_preferences_windows/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 2.1.1
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
+
 ## 2.1.0
 
 * Deprecated `SharedPreferencesWindows.instance` in favor of `SharedPreferencesStorePlatform.instance`.
diff --git a/packages/shared_preferences/shared_preferences_windows/example/lib/main.dart b/packages/shared_preferences/shared_preferences_windows/example/lib/main.dart
index 40a9159..74d5e4c 100644
--- a/packages/shared_preferences/shared_preferences_windows/example/lib/main.dart
+++ b/packages/shared_preferences/shared_preferences_windows/example/lib/main.dart
@@ -10,10 +10,12 @@
 import 'package:shared_preferences_windows/shared_preferences_windows.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 class MyApp extends StatelessWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     return const MaterialApp(
diff --git a/packages/shared_preferences/shared_preferences_windows/pubspec.yaml b/packages/shared_preferences/shared_preferences_windows/pubspec.yaml
index 6dcb599..99326cb 100644
--- a/packages/shared_preferences/shared_preferences_windows/pubspec.yaml
+++ b/packages/shared_preferences/shared_preferences_windows/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Windows implementation of shared_preferences
 repository: https://github.com/flutter/plugins/tree/main/packages/shared_preferences/shared_preferences_windows
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+shared_preferences%22
-version: 2.1.0
+version: 2.1.1
 
 environment:
   sdk: '>=2.12.0 <3.0.0'
diff --git a/packages/url_launcher/url_launcher/CHANGELOG.md b/packages/url_launcher/url_launcher/CHANGELOG.md
index b25956f..493412c 100644
--- a/packages/url_launcher/url_launcher/CHANGELOG.md
+++ b/packages/url_launcher/url_launcher/CHANGELOG.md
@@ -1,6 +1,8 @@
-## NEXT
+## 6.1.1
 
 * Removes unnecessary imports.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 6.1.0
 
diff --git a/packages/url_launcher/url_launcher/example/lib/main.dart b/packages/url_launcher/url_launcher/example/lib/main.dart
index 898e806..a538940 100644
--- a/packages/url_launcher/url_launcher/example/lib/main.dart
+++ b/packages/url_launcher/url_launcher/example/lib/main.dart
@@ -11,10 +11,12 @@
 import 'package:url_launcher/url_launcher.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 class MyApp extends StatelessWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     return MaterialApp(
@@ -32,7 +34,7 @@
   final String title;
 
   @override
-  _MyHomePageState createState() => _MyHomePageState();
+  State<MyHomePage> createState() => _MyHomePageState();
 }
 
 class _MyHomePageState extends State<MyHomePage> {
diff --git a/packages/url_launcher/url_launcher/lib/src/link.dart b/packages/url_launcher/url_launcher/lib/src/link.dart
index 76cb977..8c0c18e 100644
--- a/packages/url_launcher/url_launcher/lib/src/link.dart
+++ b/packages/url_launcher/url_launcher/lib/src/link.dart
@@ -86,7 +86,7 @@
 /// event channel messages to instruct the framework to push the route name.
 class DefaultLinkDelegate extends StatelessWidget {
   /// Creates a delegate for the given [link].
-  const DefaultLinkDelegate(this.link);
+  const DefaultLinkDelegate(this.link, {Key? key}) : super(key: key);
 
   /// Given a [link], creates an instance of [DefaultLinkDelegate].
   ///
diff --git a/packages/url_launcher/url_launcher/pubspec.yaml b/packages/url_launcher/url_launcher/pubspec.yaml
index 6803d71..c14b62a 100644
--- a/packages/url_launcher/url_launcher/pubspec.yaml
+++ b/packages/url_launcher/url_launcher/pubspec.yaml
@@ -3,7 +3,7 @@
   web, phone, SMS, and email schemes.
 repository: https://github.com/flutter/plugins/tree/main/packages/url_launcher/url_launcher
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+url_launcher%22
-version: 6.1.0
+version: 6.1.1
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/url_launcher/url_launcher_android/CHANGELOG.md b/packages/url_launcher/url_launcher_android/CHANGELOG.md
index 69b9615..887178c 100644
--- a/packages/url_launcher/url_launcher_android/CHANGELOG.md
+++ b/packages/url_launcher/url_launcher_android/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 6.0.17
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
+
 ## 6.0.16
 
 * Adds fallback querying for `canLaunch` with web URLs, to avoid false negatives
diff --git a/packages/url_launcher/url_launcher_android/example/lib/main.dart b/packages/url_launcher/url_launcher_android/example/lib/main.dart
index 7abc734..672ae4a 100644
--- a/packages/url_launcher/url_launcher_android/example/lib/main.dart
+++ b/packages/url_launcher/url_launcher_android/example/lib/main.dart
@@ -10,10 +10,12 @@
 import 'package:url_launcher_platform_interface/url_launcher_platform_interface.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 class MyApp extends StatelessWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     return MaterialApp(
@@ -31,7 +33,7 @@
   final String title;
 
   @override
-  _MyHomePageState createState() => _MyHomePageState();
+  State<MyHomePage> createState() => _MyHomePageState();
 }
 
 class _MyHomePageState extends State<MyHomePage> {
diff --git a/packages/url_launcher/url_launcher_android/pubspec.yaml b/packages/url_launcher/url_launcher_android/pubspec.yaml
index 3230dfe..3c80170 100644
--- a/packages/url_launcher/url_launcher_android/pubspec.yaml
+++ b/packages/url_launcher/url_launcher_android/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Android implementation of the url_launcher plugin.
 repository: https://github.com/flutter/plugins/tree/main/packages/url_launcher/url_launcher_android
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+url_launcher%22
-version: 6.0.16
+version: 6.0.17
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/url_launcher/url_launcher_ios/CHANGELOG.md b/packages/url_launcher/url_launcher_ios/CHANGELOG.md
index 6e0c8d6..5f6dd37 100644
--- a/packages/url_launcher/url_launcher_ios/CHANGELOG.md
+++ b/packages/url_launcher/url_launcher_ios/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 6.0.16
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
+
 ## 6.0.15
 
 * Switches to an in-package method channel implementation.
diff --git a/packages/url_launcher/url_launcher_ios/example/lib/main.dart b/packages/url_launcher/url_launcher_ios/example/lib/main.dart
index 2f73622..7aa3a4b 100644
--- a/packages/url_launcher/url_launcher_ios/example/lib/main.dart
+++ b/packages/url_launcher/url_launcher_ios/example/lib/main.dart
@@ -10,10 +10,12 @@
 import 'package:url_launcher_platform_interface/url_launcher_platform_interface.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 class MyApp extends StatelessWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     return MaterialApp(
@@ -31,7 +33,7 @@
   final String title;
 
   @override
-  _MyHomePageState createState() => _MyHomePageState();
+  State<MyHomePage> createState() => _MyHomePageState();
 }
 
 class _MyHomePageState extends State<MyHomePage> {
diff --git a/packages/url_launcher/url_launcher_ios/pubspec.yaml b/packages/url_launcher/url_launcher_ios/pubspec.yaml
index 8a5bfd2..0b21bad 100644
--- a/packages/url_launcher/url_launcher_ios/pubspec.yaml
+++ b/packages/url_launcher/url_launcher_ios/pubspec.yaml
@@ -2,7 +2,7 @@
 description: iOS implementation of the url_launcher plugin.
 repository: https://github.com/flutter/plugins/tree/main/packages/url_launcher/url_launcher_ios
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+url_launcher%22
-version: 6.0.15
+version: 6.0.16
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/url_launcher/url_launcher_linux/CHANGELOG.md b/packages/url_launcher/url_launcher_linux/CHANGELOG.md
index 0fc373f..27c18a6 100644
--- a/packages/url_launcher/url_launcher_linux/CHANGELOG.md
+++ b/packages/url_launcher/url_launcher_linux/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 3.0.1
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
+
 ## 3.0.0
 
 * Changes the major version since, due to a typo in `default_package` in
diff --git a/packages/url_launcher/url_launcher_linux/example/lib/main.dart b/packages/url_launcher/url_launcher_linux/example/lib/main.dart
index a9a5d22..0b985e7 100644
--- a/packages/url_launcher/url_launcher_linux/example/lib/main.dart
+++ b/packages/url_launcher/url_launcher_linux/example/lib/main.dart
@@ -9,10 +9,12 @@
 import 'package:url_launcher_platform_interface/url_launcher_platform_interface.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 class MyApp extends StatelessWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     return MaterialApp(
@@ -30,7 +32,7 @@
   final String title;
 
   @override
-  _MyHomePageState createState() => _MyHomePageState();
+  State<MyHomePage> createState() => _MyHomePageState();
 }
 
 class _MyHomePageState extends State<MyHomePage> {
diff --git a/packages/url_launcher/url_launcher_linux/pubspec.yaml b/packages/url_launcher/url_launcher_linux/pubspec.yaml
index cb9a0be..c947204 100644
--- a/packages/url_launcher/url_launcher_linux/pubspec.yaml
+++ b/packages/url_launcher/url_launcher_linux/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Linux implementation of the url_launcher plugin.
 repository: https://github.com/flutter/plugins/tree/main/packages/url_launcher/url_launcher_linux
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+url_launcher%22
-version: 3.0.0
+version: 3.0.1
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/url_launcher/url_launcher_macos/CHANGELOG.md b/packages/url_launcher/url_launcher_macos/CHANGELOG.md
index 082bc45..2fa5e91 100644
--- a/packages/url_launcher/url_launcher_macos/CHANGELOG.md
+++ b/packages/url_launcher/url_launcher_macos/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 3.0.1
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
+
 ## 3.0.0
 
 * Changes the major version since, due to a typo in `default_package` in
diff --git a/packages/url_launcher/url_launcher_macos/example/lib/main.dart b/packages/url_launcher/url_launcher_macos/example/lib/main.dart
index a9a5d22..0b985e7 100644
--- a/packages/url_launcher/url_launcher_macos/example/lib/main.dart
+++ b/packages/url_launcher/url_launcher_macos/example/lib/main.dart
@@ -9,10 +9,12 @@
 import 'package:url_launcher_platform_interface/url_launcher_platform_interface.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 class MyApp extends StatelessWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     return MaterialApp(
@@ -30,7 +32,7 @@
   final String title;
 
   @override
-  _MyHomePageState createState() => _MyHomePageState();
+  State<MyHomePage> createState() => _MyHomePageState();
 }
 
 class _MyHomePageState extends State<MyHomePage> {
diff --git a/packages/url_launcher/url_launcher_macos/pubspec.yaml b/packages/url_launcher/url_launcher_macos/pubspec.yaml
index 8b5183b..edda6b6 100644
--- a/packages/url_launcher/url_launcher_macos/pubspec.yaml
+++ b/packages/url_launcher/url_launcher_macos/pubspec.yaml
@@ -2,7 +2,7 @@
 description: macOS implementation of the url_launcher plugin.
 repository: https://github.com/flutter/plugins/tree/main/packages/url_launcher/url_launcher_macos
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+url_launcher%22
-version: 3.0.0
+version: 3.0.1
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/url_launcher/url_launcher_web/CHANGELOG.md b/packages/url_launcher/url_launcher_web/CHANGELOG.md
index a434b7a..b53a92c 100644
--- a/packages/url_launcher/url_launcher_web/CHANGELOG.md
+++ b/packages/url_launcher/url_launcher_web/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 2.0.10
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
+
 ## 2.0.9
 
 - Fixes invalid routes when opening a `Link` in a new tab
diff --git a/packages/url_launcher/url_launcher_web/example/lib/main.dart b/packages/url_launcher/url_launcher_web/example/lib/main.dart
index 341913a..8742295 100644
--- a/packages/url_launcher/url_launcher_web/example/lib/main.dart
+++ b/packages/url_launcher/url_launcher_web/example/lib/main.dart
@@ -5,13 +5,16 @@
 import 'package:flutter/material.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 /// App for testing
 class MyApp extends StatefulWidget {
+  /// Default Constructor
+  const MyApp({Key? key}) : super(key: key);
+
   @override
-  _MyAppState createState() => _MyAppState();
+  State<MyApp> createState() => _MyAppState();
 }
 
 class _MyAppState extends State<MyApp> {
diff --git a/packages/url_launcher/url_launcher_web/lib/src/link.dart b/packages/url_launcher/url_launcher_web/lib/src/link.dart
index 4498e74..eccd9ae 100644
--- a/packages/url_launcher/url_launcher_web/lib/src/link.dart
+++ b/packages/url_launcher/url_launcher_web/lib/src/link.dart
@@ -31,7 +31,7 @@
 /// It uses a platform view to render an anchor element in the DOM.
 class WebLinkDelegate extends StatefulWidget {
   /// Creates a delegate for the given [link].
-  const WebLinkDelegate(this.link);
+  const WebLinkDelegate(this.link, {Key? key}) : super(key: key);
 
   /// Information about the link built by the app.
   final LinkInfo link;
diff --git a/packages/url_launcher/url_launcher_web/pubspec.yaml b/packages/url_launcher/url_launcher_web/pubspec.yaml
index c45c062..cd8ed2d 100644
--- a/packages/url_launcher/url_launcher_web/pubspec.yaml
+++ b/packages/url_launcher/url_launcher_web/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Web platform implementation of url_launcher
 repository: https://github.com/flutter/plugins/tree/main/packages/url_launcher/url_launcher_web
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+url_launcher%22
-version: 2.0.9
+version: 2.0.10
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/url_launcher/url_launcher_windows/CHANGELOG.md b/packages/url_launcher/url_launcher_windows/CHANGELOG.md
index e02f5a2..3ff14fd 100644
--- a/packages/url_launcher/url_launcher_windows/CHANGELOG.md
+++ b/packages/url_launcher/url_launcher_windows/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 3.0.1
+
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
+
 ## 3.0.0
 
 * Changes the major version since, due to a typo in `default_package` in
diff --git a/packages/url_launcher/url_launcher_windows/example/lib/main.dart b/packages/url_launcher/url_launcher_windows/example/lib/main.dart
index a9a5d22..0b985e7 100644
--- a/packages/url_launcher/url_launcher_windows/example/lib/main.dart
+++ b/packages/url_launcher/url_launcher_windows/example/lib/main.dart
@@ -9,10 +9,12 @@
 import 'package:url_launcher_platform_interface/url_launcher_platform_interface.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 class MyApp extends StatelessWidget {
+  const MyApp({Key? key}) : super(key: key);
+
   @override
   Widget build(BuildContext context) {
     return MaterialApp(
@@ -30,7 +32,7 @@
   final String title;
 
   @override
-  _MyHomePageState createState() => _MyHomePageState();
+  State<MyHomePage> createState() => _MyHomePageState();
 }
 
 class _MyHomePageState extends State<MyHomePage> {
diff --git a/packages/url_launcher/url_launcher_windows/pubspec.yaml b/packages/url_launcher/url_launcher_windows/pubspec.yaml
index 95f17ad..c3f224e 100644
--- a/packages/url_launcher/url_launcher_windows/pubspec.yaml
+++ b/packages/url_launcher/url_launcher_windows/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Windows implementation of the url_launcher plugin.
 repository: https://github.com/flutter/plugins/tree/main/packages/url_launcher/url_launcher_windows
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+url_launcher%22
-version: 3.0.0
+version: 3.0.1
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/video_player/video_player/CHANGELOG.md b/packages/video_player/video_player/CHANGELOG.md
index af01c64..ede8901 100644
--- a/packages/video_player/video_player/CHANGELOG.md
+++ b/packages/video_player/video_player/CHANGELOG.md
@@ -1,6 +1,8 @@
-## NEXT
+## 2.4.1
 
 * Removes unnecessary imports.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 2.4.0
 
diff --git a/packages/video_player/video_player/lib/video_player.dart b/packages/video_player/video_player/lib/video_player.dart
index 39cd415..a6ec510 100644
--- a/packages/video_player/video_player/lib/video_player.dart
+++ b/packages/video_player/video_player/lib/video_player.dart
@@ -708,14 +708,14 @@
 /// Widget that displays the video controlled by [controller].
 class VideoPlayer extends StatefulWidget {
   /// Uses the given [controller] for all video rendered in this widget.
-  const VideoPlayer(this.controller);
+  const VideoPlayer(this.controller, {Key? key}) : super(key: key);
 
   /// The [VideoPlayerController] responsible for the video being rendered in
   /// this widget.
   final VideoPlayerController controller;
 
   @override
-  _VideoPlayerState createState() => _VideoPlayerState();
+  State<VideoPlayer> createState() => _VideoPlayerState();
 }
 
 class _VideoPlayerState extends State<VideoPlayer> {
@@ -883,10 +883,11 @@
   /// to `top: 5.0`.
   const VideoProgressIndicator(
     this.controller, {
+    Key? key,
     this.colors = const VideoProgressColors(),
     required this.allowScrubbing,
     this.padding = const EdgeInsets.only(top: 5.0),
-  });
+  }) : super(key: key);
 
   /// The [VideoPlayerController] that actually associates a video with this
   /// widget.
@@ -910,7 +911,7 @@
   final EdgeInsets padding;
 
   @override
-  _VideoProgressIndicatorState createState() => _VideoProgressIndicatorState();
+  State<VideoProgressIndicator> createState() => _VideoProgressIndicatorState();
 }
 
 class _VideoProgressIndicatorState extends State<VideoProgressIndicator> {
@@ -984,8 +985,8 @@
     );
     if (widget.allowScrubbing) {
       return _VideoScrubber(
-        child: paddedProgressIndicator,
         controller: controller,
+        child: paddedProgressIndicator,
       );
     } else {
       return paddedProgressIndicator;
diff --git a/packages/video_player/video_player/pubspec.yaml b/packages/video_player/video_player/pubspec.yaml
index 0d654a4..b0ca564 100644
--- a/packages/video_player/video_player/pubspec.yaml
+++ b/packages/video_player/video_player/pubspec.yaml
@@ -3,7 +3,7 @@
   widgets on Android, iOS, and web.
 repository: https://github.com/flutter/plugins/tree/main/packages/video_player/video_player
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+video_player%22
-version: 2.4.0
+version: 2.4.1
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/video_player/video_player_android/CHANGELOG.md b/packages/video_player/video_player_android/CHANGELOG.md
index 16dd52c..08acba8 100644
--- a/packages/video_player/video_player_android/CHANGELOG.md
+++ b/packages/video_player/video_player_android/CHANGELOG.md
@@ -1,6 +1,8 @@
-## NEXT
+## 2.3.3
 
 * Removes unnecessary imports.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 2.3.2
 
diff --git a/packages/video_player/video_player_android/example/lib/mini_controller.dart b/packages/video_player/video_player_android/example/lib/mini_controller.dart
index 498dbff..5bce311 100644
--- a/packages/video_player/video_player_android/example/lib/mini_controller.dart
+++ b/packages/video_player/video_player_android/example/lib/mini_controller.dart
@@ -351,14 +351,14 @@
 /// Widget that displays the video controlled by [controller].
 class VideoPlayer extends StatefulWidget {
   /// Uses the given [controller] for all video rendered in this widget.
-  const VideoPlayer(this.controller);
+  const VideoPlayer(this.controller, {Key? key}) : super(key: key);
 
   /// The [MiniController] responsible for the video being rendered in
   /// this widget.
   final MiniController controller;
 
   @override
-  _VideoPlayerState createState() => _VideoPlayerState();
+  State<VideoPlayer> createState() => _VideoPlayerState();
 }
 
 class _VideoPlayerState extends State<VideoPlayer> {
@@ -450,14 +450,14 @@
 class VideoProgressIndicator extends StatefulWidget {
   /// Construct an instance that displays the play/buffering status of the video
   /// controlled by [controller].
-  const VideoProgressIndicator(this.controller);
+  const VideoProgressIndicator(this.controller, {Key? key}) : super(key: key);
 
   /// The [MiniController] that actually associates a video with this
   /// widget.
   final MiniController controller;
 
   @override
-  _VideoProgressIndicatorState createState() => _VideoProgressIndicatorState();
+  State<VideoProgressIndicator> createState() => _VideoProgressIndicatorState();
 }
 
 class _VideoProgressIndicatorState extends State<VideoProgressIndicator> {
@@ -527,11 +527,11 @@
       );
     }
     return _VideoScrubber(
+      controller: controller,
       child: Padding(
         padding: const EdgeInsets.only(top: 5.0),
         child: progressIndicator,
       ),
-      controller: controller,
     );
   }
 }
diff --git a/packages/video_player/video_player_android/pubspec.yaml b/packages/video_player/video_player_android/pubspec.yaml
index aa288ed..bc69fd4 100644
--- a/packages/video_player/video_player_android/pubspec.yaml
+++ b/packages/video_player/video_player_android/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Android implementation of the video_player plugin.
 repository: https://github.com/flutter/plugins/tree/master/packages/video_player/video_player_android
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+video_player%22
-version: 2.3.2
+version: 2.3.3
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/video_player/video_player_avfoundation/CHANGELOG.md b/packages/video_player/video_player_avfoundation/CHANGELOG.md
index d77c36c..6ab5398 100644
--- a/packages/video_player/video_player_avfoundation/CHANGELOG.md
+++ b/packages/video_player/video_player_avfoundation/CHANGELOG.md
@@ -1,6 +1,8 @@
-## NEXT
+## 2.3.4
 
 * Removes unnecessary imports.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 2.3.3
 
diff --git a/packages/video_player/video_player_avfoundation/example/lib/mini_controller.dart b/packages/video_player/video_player_avfoundation/example/lib/mini_controller.dart
index 498dbff..5bce311 100644
--- a/packages/video_player/video_player_avfoundation/example/lib/mini_controller.dart
+++ b/packages/video_player/video_player_avfoundation/example/lib/mini_controller.dart
@@ -351,14 +351,14 @@
 /// Widget that displays the video controlled by [controller].
 class VideoPlayer extends StatefulWidget {
   /// Uses the given [controller] for all video rendered in this widget.
-  const VideoPlayer(this.controller);
+  const VideoPlayer(this.controller, {Key? key}) : super(key: key);
 
   /// The [MiniController] responsible for the video being rendered in
   /// this widget.
   final MiniController controller;
 
   @override
-  _VideoPlayerState createState() => _VideoPlayerState();
+  State<VideoPlayer> createState() => _VideoPlayerState();
 }
 
 class _VideoPlayerState extends State<VideoPlayer> {
@@ -450,14 +450,14 @@
 class VideoProgressIndicator extends StatefulWidget {
   /// Construct an instance that displays the play/buffering status of the video
   /// controlled by [controller].
-  const VideoProgressIndicator(this.controller);
+  const VideoProgressIndicator(this.controller, {Key? key}) : super(key: key);
 
   /// The [MiniController] that actually associates a video with this
   /// widget.
   final MiniController controller;
 
   @override
-  _VideoProgressIndicatorState createState() => _VideoProgressIndicatorState();
+  State<VideoProgressIndicator> createState() => _VideoProgressIndicatorState();
 }
 
 class _VideoProgressIndicatorState extends State<VideoProgressIndicator> {
@@ -527,11 +527,11 @@
       );
     }
     return _VideoScrubber(
+      controller: controller,
       child: Padding(
         padding: const EdgeInsets.only(top: 5.0),
         child: progressIndicator,
       ),
-      controller: controller,
     );
   }
 }
diff --git a/packages/video_player/video_player_avfoundation/pubspec.yaml b/packages/video_player/video_player_avfoundation/pubspec.yaml
index b3cc69e..380d834 100644
--- a/packages/video_player/video_player_avfoundation/pubspec.yaml
+++ b/packages/video_player/video_player_avfoundation/pubspec.yaml
@@ -2,7 +2,7 @@
 description: iOS implementation of the video_player plugin.
 repository: https://github.com/flutter/plugins/tree/master/packages/video_player/video_player_avfoundation
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+video_player%22
-version: 2.3.3
+version: 2.3.4
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/video_player/video_player_web/CHANGELOG.md b/packages/video_player/video_player_web/CHANGELOG.md
index 00788c4..094ffda 100644
--- a/packages/video_player/video_player_web/CHANGELOG.md
+++ b/packages/video_player/video_player_web/CHANGELOG.md
@@ -1,6 +1,8 @@
-## NEXT
+## 2.0.9
 
 * Removes unnecessary imports.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 2.0.8
 
diff --git a/packages/video_player/video_player_web/example/lib/main.dart b/packages/video_player/video_player_web/example/lib/main.dart
index 341913a..8742295 100644
--- a/packages/video_player/video_player_web/example/lib/main.dart
+++ b/packages/video_player/video_player_web/example/lib/main.dart
@@ -5,13 +5,16 @@
 import 'package:flutter/material.dart';
 
 void main() {
-  runApp(MyApp());
+  runApp(const MyApp());
 }
 
 /// App for testing
 class MyApp extends StatefulWidget {
+  /// Default Constructor
+  const MyApp({Key? key}) : super(key: key);
+
   @override
-  _MyAppState createState() => _MyAppState();
+  State<MyApp> createState() => _MyAppState();
 }
 
 class _MyAppState extends State<MyApp> {
diff --git a/packages/video_player/video_player_web/pubspec.yaml b/packages/video_player/video_player_web/pubspec.yaml
index 064517e..7af0dc4 100644
--- a/packages/video_player/video_player_web/pubspec.yaml
+++ b/packages/video_player/video_player_web/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Web platform implementation of video_player.
 repository: https://github.com/flutter/plugins/tree/main/packages/video_player/video_player_web
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+video_player%22
-version: 2.0.8
+version: 2.0.9
 
 environment:
   sdk: ">=2.12.0 <3.0.0"
diff --git a/packages/webview_flutter/webview_flutter/CHANGELOG.md b/packages/webview_flutter/webview_flutter/CHANGELOG.md
index 7a56f3f..fa47a6c 100644
--- a/packages/webview_flutter/webview_flutter/CHANGELOG.md
+++ b/packages/webview_flutter/webview_flutter/CHANGELOG.md
@@ -1,6 +1,8 @@
-## NEXT
+## 3.0.3
 
 * Removes unnecessary imports.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 3.0.2
 
@@ -11,7 +13,7 @@
 
 * Removes a duplicate Android-specific integration test.
 * Fixes an integration test race condition.
-* Fixes comments (accidentially mixed // with ///).
+* Fixes comments (accidentally mixed // with ///).
 
 ## 3.0.0
 
diff --git a/packages/webview_flutter/webview_flutter/example/integration_test/webview_flutter_test.dart b/packages/webview_flutter/webview_flutter/example/integration_test/webview_flutter_test.dart
index ba32126..cc001f3 100644
--- a/packages/webview_flutter/webview_flutter/example/integration_test/webview_flutter_test.dart
+++ b/packages/webview_flutter/webview_flutter/example/integration_test/webview_flutter_test.dart
@@ -1306,7 +1306,8 @@
 
 class ResizableWebView extends StatefulWidget {
   const ResizableWebView(
-      {required this.onResize, required this.onPageFinished});
+      {Key? key, required this.onResize, required this.onPageFinished})
+      : super(key: key);
 
   final JavascriptMessageHandler onResize;
   final VoidCallback onPageFinished;
diff --git a/packages/webview_flutter/webview_flutter/example/lib/main.dart b/packages/webview_flutter/webview_flutter/example/lib/main.dart
index 51080be..3d87311 100644
--- a/packages/webview_flutter/webview_flutter/example/lib/main.dart
+++ b/packages/webview_flutter/webview_flutter/example/lib/main.dart
@@ -71,12 +71,12 @@
 ''';
 
 class WebViewExample extends StatefulWidget {
-  const WebViewExample({this.cookieManager});
+  const WebViewExample({Key? key, this.cookieManager}) : super(key: key);
 
   final CookieManager? cookieManager;
 
   @override
-  _WebViewExampleState createState() => _WebViewExampleState();
+  State<WebViewExample> createState() => _WebViewExampleState();
 }
 
 class _WebViewExampleState extends State<WebViewExample> {
@@ -190,8 +190,9 @@
 }
 
 class SampleMenu extends StatelessWidget {
-  SampleMenu(this.controller, CookieManager? cookieManager)
-      : cookieManager = cookieManager ?? CookieManager();
+  SampleMenu(this.controller, CookieManager? cookieManager, {Key? key})
+      : cookieManager = cookieManager ?? CookieManager(),
+        super(key: key);
 
   final Future<WebViewController> controller;
   late final CookieManager cookieManager;
@@ -250,8 +251,8 @@
           itemBuilder: (BuildContext context) => <PopupMenuItem<MenuOptions>>[
             PopupMenuItem<MenuOptions>(
               value: MenuOptions.showUserAgent,
-              child: const Text('Show user agent'),
               enabled: controller.hasData,
+              child: const Text('Show user agent'),
             ),
             const PopupMenuItem<MenuOptions>(
               value: MenuOptions.listCookies,
@@ -443,8 +444,9 @@
 }
 
 class NavigationControls extends StatelessWidget {
-  const NavigationControls(this._webViewControllerFuture)
-      : assert(_webViewControllerFuture != null);
+  const NavigationControls(this._webViewControllerFuture, {Key? key})
+      : assert(_webViewControllerFuture != null),
+        super(key: key);
 
   final Future<WebViewController> _webViewControllerFuture;
 
diff --git a/packages/webview_flutter/webview_flutter/pubspec.yaml b/packages/webview_flutter/webview_flutter/pubspec.yaml
index 1035098..a48f6f9 100644
--- a/packages/webview_flutter/webview_flutter/pubspec.yaml
+++ b/packages/webview_flutter/webview_flutter/pubspec.yaml
@@ -2,7 +2,7 @@
 description: A Flutter plugin that provides a WebView widget on Android and iOS.
 repository: https://github.com/flutter/plugins/tree/main/packages/webview_flutter/webview_flutter
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+webview%22
-version: 3.0.2
+version: 3.0.3
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/webview_flutter/webview_flutter_android/CHANGELOG.md b/packages/webview_flutter/webview_flutter_android/CHANGELOG.md
index edaa088..4a45144 100644
--- a/packages/webview_flutter/webview_flutter_android/CHANGELOG.md
+++ b/packages/webview_flutter/webview_flutter_android/CHANGELOG.md
@@ -1,6 +1,8 @@
-## NEXT
+## 2.8.7
 
 * Removes unnecessary imports.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 2.8.6
 
diff --git a/packages/webview_flutter/webview_flutter_android/example/integration_test/webview_flutter_test.dart b/packages/webview_flutter/webview_flutter_android/example/integration_test/webview_flutter_test.dart
index 51e0991..4c06fa6 100644
--- a/packages/webview_flutter/webview_flutter_android/example/integration_test/webview_flutter_test.dart
+++ b/packages/webview_flutter/webview_flutter_android/example/integration_test/webview_flutter_test.dart
@@ -1446,9 +1446,10 @@
 
 class ResizableWebView extends StatefulWidget {
   const ResizableWebView({
+    Key? key,
     required this.onResize,
     required this.onPageFinished,
-  });
+  }) : super(key: key);
 
   final JavascriptMessageHandler onResize;
   final VoidCallback onPageFinished;
diff --git a/packages/webview_flutter/webview_flutter_android/example/lib/main.dart b/packages/webview_flutter/webview_flutter_android/example/lib/main.dart
index 5d19ca7..349a649 100644
--- a/packages/webview_flutter/webview_flutter_android/example/lib/main.dart
+++ b/packages/webview_flutter/webview_flutter_android/example/lib/main.dart
@@ -247,8 +247,8 @@
           itemBuilder: (BuildContext context) => <PopupMenuItem<_MenuOptions>>[
             PopupMenuItem<_MenuOptions>(
               value: _MenuOptions.showUserAgent,
-              child: const Text('Show user agent'),
               enabled: controller.hasData,
+              child: const Text('Show user agent'),
             ),
             const PopupMenuItem<_MenuOptions>(
               value: _MenuOptions.listCookies,
diff --git a/packages/webview_flutter/webview_flutter_android/example/lib/web_view.dart b/packages/webview_flutter/webview_flutter_android/example/lib/web_view.dart
index 91ea663..5674531 100644
--- a/packages/webview_flutter/webview_flutter_android/example/lib/web_view.dart
+++ b/packages/webview_flutter/webview_flutter_android/example/lib/web_view.dart
@@ -250,7 +250,7 @@
   final Color? backgroundColor;
 
   @override
-  _WebViewState createState() => _WebViewState();
+  State<WebView> createState() => _WebViewState();
 }
 
 class _WebViewState extends State<WebView> {
diff --git a/packages/webview_flutter/webview_flutter_android/lib/webview_android_widget.dart b/packages/webview_flutter/webview_flutter_android/lib/webview_android_widget.dart
index 28d169c..f1b130c 100644
--- a/packages/webview_flutter/webview_flutter_android/lib/webview_android_widget.dart
+++ b/packages/webview_flutter/webview_flutter_android/lib/webview_android_widget.dart
@@ -15,6 +15,7 @@
 class WebViewAndroidWidget extends StatefulWidget {
   /// Constructs a [WebViewAndroidWidget].
   const WebViewAndroidWidget({
+    Key? key,
     required this.creationParams,
     required this.useHybridComposition,
     required this.callbacksHandler,
@@ -24,7 +25,7 @@
     @visibleForTesting
         this.flutterAssetManager = const android_webview.FlutterAssetManager(),
     @visibleForTesting this.webStorage,
-  });
+  }) : super(key: key);
 
   /// Initial parameters used to setup the WebView.
   final CreationParams creationParams;
diff --git a/packages/webview_flutter/webview_flutter_android/pubspec.yaml b/packages/webview_flutter/webview_flutter_android/pubspec.yaml
index 9a7c48a..407887f 100644
--- a/packages/webview_flutter/webview_flutter_android/pubspec.yaml
+++ b/packages/webview_flutter/webview_flutter_android/pubspec.yaml
@@ -2,7 +2,7 @@
 description: A Flutter plugin that provides a WebView widget on Android.
 repository: https://github.com/flutter/plugins/tree/main/packages/webview_flutter/webview_flutter_android
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+webview%22
-version: 2.8.6
+version: 2.8.7
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/webview_flutter/webview_flutter_web/CHANGELOG.md b/packages/webview_flutter/webview_flutter_web/CHANGELOG.md
index 9f7ebe3..b7254e1 100644
--- a/packages/webview_flutter/webview_flutter_web/CHANGELOG.md
+++ b/packages/webview_flutter/webview_flutter_web/CHANGELOG.md
@@ -1,7 +1,9 @@
-## NEXT
+## 0.1.0+2
 
 * Removes unnecessary imports.
 * Fixes unit tests to run on latest `master` version of Flutter.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 0.1.0+1
 
diff --git a/packages/webview_flutter/webview_flutter_web/example/lib/web_view.dart b/packages/webview_flutter/webview_flutter_web/example/lib/web_view.dart
index 8cd74f6..ffd3367 100644
--- a/packages/webview_flutter/webview_flutter_web/example/lib/web_view.dart
+++ b/packages/webview_flutter/webview_flutter_web/example/lib/web_view.dart
@@ -46,7 +46,7 @@
   final String? initialUrl;
 
   @override
-  _WebViewState createState() => _WebViewState();
+  State<WebView> createState() => _WebViewState();
 }
 
 class _WebViewState extends State<WebView> {
diff --git a/packages/webview_flutter/webview_flutter_web/pubspec.yaml b/packages/webview_flutter/webview_flutter_web/pubspec.yaml
index bd15438..35a7b74 100644
--- a/packages/webview_flutter/webview_flutter_web/pubspec.yaml
+++ b/packages/webview_flutter/webview_flutter_web/pubspec.yaml
@@ -2,7 +2,7 @@
 description: A Flutter plugin that provides a WebView widget on web.
 repository: https://github.com/flutter/plugins/tree/main/packages/webview_flutter/webview_flutter_web
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+webview%22
-version: 0.1.0+1
+version: 0.1.0+2
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/packages/webview_flutter/webview_flutter_wkwebview/CHANGELOG.md b/packages/webview_flutter/webview_flutter_wkwebview/CHANGELOG.md
index f042dd0..6db769b 100644
--- a/packages/webview_flutter/webview_flutter_wkwebview/CHANGELOG.md
+++ b/packages/webview_flutter/webview_flutter_wkwebview/CHANGELOG.md
@@ -1,6 +1,8 @@
-## NEXT
+## 2.7.4
 
 * Removes unnecessary imports.
+* Fixes library_private_types_in_public_api, sort_child_properties_last and use_key_in_widget_constructors
+  lint warnings.
 
 ## 2.7.3
 
diff --git a/packages/webview_flutter/webview_flutter_wkwebview/example/integration_test/webview_flutter_test.dart b/packages/webview_flutter/webview_flutter_wkwebview/example/integration_test/webview_flutter_test.dart
index ceff62e..aa376f8 100644
--- a/packages/webview_flutter/webview_flutter_wkwebview/example/integration_test/webview_flutter_test.dart
+++ b/packages/webview_flutter/webview_flutter_wkwebview/example/integration_test/webview_flutter_test.dart
@@ -1181,7 +1181,8 @@
 
 class ResizableWebView extends StatefulWidget {
   const ResizableWebView(
-      {required this.onResize, required this.onPageFinished});
+      {Key? key, required this.onResize, required this.onPageFinished})
+      : super(key: key);
 
   final JavascriptMessageHandler onResize;
   final VoidCallback onPageFinished;
diff --git a/packages/webview_flutter/webview_flutter_wkwebview/example/lib/main.dart b/packages/webview_flutter/webview_flutter_wkwebview/example/lib/main.dart
index e8b86d9..7b30923 100644
--- a/packages/webview_flutter/webview_flutter_wkwebview/example/lib/main.dart
+++ b/packages/webview_flutter/webview_flutter_wkwebview/example/lib/main.dart
@@ -232,8 +232,8 @@
           itemBuilder: (BuildContext context) => <PopupMenuItem<_MenuOptions>>[
             PopupMenuItem<_MenuOptions>(
               value: _MenuOptions.showUserAgent,
-              child: const Text('Show user agent'),
               enabled: controller.hasData,
+              child: const Text('Show user agent'),
             ),
             const PopupMenuItem<_MenuOptions>(
               value: _MenuOptions.listCookies,
diff --git a/packages/webview_flutter/webview_flutter_wkwebview/example/lib/web_view.dart b/packages/webview_flutter/webview_flutter_wkwebview/example/lib/web_view.dart
index 4d479f9..c44c4e7 100644
--- a/packages/webview_flutter/webview_flutter_wkwebview/example/lib/web_view.dart
+++ b/packages/webview_flutter/webview_flutter_wkwebview/example/lib/web_view.dart
@@ -240,7 +240,7 @@
   final Color? backgroundColor;
 
   @override
-  _WebViewState createState() => _WebViewState();
+  State<WebView> createState() => _WebViewState();
 }
 
 class _WebViewState extends State<WebView> {
diff --git a/packages/webview_flutter/webview_flutter_wkwebview/lib/src/web_kit_webview_widget.dart b/packages/webview_flutter/webview_flutter_wkwebview/lib/src/web_kit_webview_widget.dart
index 012cd22..8c37112 100644
--- a/packages/webview_flutter/webview_flutter_wkwebview/lib/src/web_kit_webview_widget.dart
+++ b/packages/webview_flutter/webview_flutter_wkwebview/lib/src/web_kit_webview_widget.dart
@@ -18,13 +18,14 @@
 class WebKitWebViewWidget extends StatefulWidget {
   /// Constructs a [WebKitWebViewWidget].
   const WebKitWebViewWidget({
+    Key? key,
     required this.creationParams,
     required this.callbacksHandler,
     required this.javascriptChannelRegistry,
     required this.onBuildWidget,
     this.configuration,
     @visibleForTesting this.webViewProxy = const WebViewWidgetProxy(),
-  });
+  }) : super(key: key);
 
   /// The initial parameters used to setup the WebView.
   final CreationParams creationParams;
diff --git a/packages/webview_flutter/webview_flutter_wkwebview/pubspec.yaml b/packages/webview_flutter/webview_flutter_wkwebview/pubspec.yaml
index f4e72b8..365e647 100644
--- a/packages/webview_flutter/webview_flutter_wkwebview/pubspec.yaml
+++ b/packages/webview_flutter/webview_flutter_wkwebview/pubspec.yaml
@@ -2,7 +2,7 @@
 description: A Flutter plugin that provides a WebView widget based on Apple's WKWebView control.
 repository: https://github.com/flutter/plugins/tree/main/packages/webview_flutter/webview_flutter_wkwebview
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+webview%22
-version: 2.7.3
+version: 2.7.4
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
diff --git a/script/tool/test/util.dart b/script/tool/test/util.dart
index 5c38bd5..b0a8990 100644
--- a/script/tool/test/util.dart
+++ b/script/tool/test/util.dart
@@ -319,14 +319,14 @@
   return entry;
 }
 
-typedef _ErrorHandler = void Function(Error error);
+typedef ErrorHandler = void Function(Error error);
 
 /// Run the command [runner] with the given [args] and return
 /// what was printed.
 /// A custom [errorHandler] can be used to handle the runner error as desired without throwing.
 Future<List<String>> runCapturingPrint(
     CommandRunner<void> runner, List<String> args,
-    {_ErrorHandler? errorHandler}) async {
+    {ErrorHandler? errorHandler}) async {
   final List<String> prints = <String>[];
   final ZoneSpecification spec = ZoneSpecification(
     print: (_, __, ___, String message) {
