Use named arguments in public request clients

src/Client/Public/Requests/Atproto/IdentityPublicRequestClient.php

···
 {
     public function resolveHandle(string $handle): string
     {
-        $response = $this->atp->client->get(AtprotoIdentity::ResolveHandle, compact('handle'));
+        $response = $this->atp->client->get(
+            endpoint: AtprotoIdentity::ResolveHandle,
+            params: compact('handle')
+        );
 
         return $response->json()['did'];
     }

src/Client/Public/Requests/Atproto/RepoPublicRequestClient.php

···
         ?string $cid = null
     ): GetRecordResponse {
         $response = $this->atp->client->get(
-            AtprotoRepo::GetRecord,
-            compact('repo', 'collection', 'rkey', 'cid')
+            endpoint: AtprotoRepo::GetRecord,
+            params: compact('repo', 'collection', 'rkey', 'cid')
         );
 
         return GetRecordResponse::fromArray($response->json());
···
         bool $reverse = false
     ): ListRecordsResponse {
         $response = $this->atp->client->get(
-            AtprotoRepo::ListRecords,
-            compact('repo', 'collection', 'limit', 'cursor', 'reverse')
+            endpoint: AtprotoRepo::ListRecords,
+            params: compact('repo', 'collection', 'limit', 'cursor', 'reverse')
         );
 
         return ListRecordsResponse::fromArray($response->json());
···
     public function describeRepo(string $repo): DescribeRepoResponse
     {
         $response = $this->atp->client->get(
-            AtprotoRepo::DescribeRepo,
-            compact('repo')
+            endpoint: AtprotoRepo::DescribeRepo,
+            params: compact('repo')
         );
 
         return DescribeRepoResponse::fromArray($response->json());

src/Client/Public/Requests/Bsky/ActorPublicRequestClient.php

···
 {
     public function getProfile(string $actor): ProfileViewDetailed
     {
-        $response = $this->atp->client->get(BskyActor::GetProfile, compact('actor'));
+        $response = $this->atp->client->get(
+            endpoint: BskyActor::GetProfile,
+            params: compact('actor')
+        );
 
         return ProfileViewDetailed::fromArray($response->json());
     }
 
     public function getProfiles(array $actors): GetProfilesResponse
     {
-        $response = $this->atp->client->get(BskyActor::GetProfiles, compact('actors'));
+        $response = $this->atp->client->get(
+            endpoint: BskyActor::GetProfiles,
+            params: compact('actors')
+        );
 
         return GetProfilesResponse::fromArray($response->json());
     }
 
     public function getSuggestions(int $limit = 50, ?string $cursor = null): GetSuggestionsResponse
     {
-        $response = $this->atp->client->get(BskyActor::GetSuggestions, compact('limit', 'cursor'));
+        $response = $this->atp->client->get(
+            endpoint: BskyActor::GetSuggestions,
+            params: compact('limit', 'cursor')
+        );
 
         return GetSuggestionsResponse::fromArray($response->json());
     }
 
     public function searchActors(string $q, int $limit = 25, ?string $cursor = null): SearchActorsResponse
     {
-        $response = $this->atp->client->get(BskyActor::SearchActors, compact('q', 'limit', 'cursor'));
+        $response = $this->atp->client->get(
+            endpoint: BskyActor::SearchActors,
+            params: compact('q', 'limit', 'cursor')
+        );
 
         return SearchActorsResponse::fromArray($response->json());
     }
 
     public function searchActorsTypeahead(string $q, int $limit = 10): SearchActorsTypeaheadResponse
     {
-        $response = $this->atp->client->get(BskyActor::SearchActorsTypeahead, compact('q', 'limit'));
+        $response = $this->atp->client->get(
+            endpoint: BskyActor::SearchActorsTypeahead,
+            params: compact('q', 'limit')
+        );
 
         return SearchActorsTypeaheadResponse::fromArray($response->json());
     }

src/Client/Public/Requests/Bsky/FeedPublicRequestClient.php

···
 {
     public function describeFeedGenerator(): DescribeFeedGeneratorResponse
     {
-        $response = $this->atp->client->get(BskyFeed::DescribeFeedGenerator);
+        $response = $this->atp->client->get(
+            endpoint: BskyFeed::DescribeFeedGenerator
+        );
 
         return DescribeFeedGeneratorResponse::fromArray($response->json());
     }
 
     public function getAuthorFeed(string $actor, int $limit = 50, ?string $cursor = null, ?string $filter = null): GetAuthorFeedResponse
     {
-        $response = $this->atp->client->get(BskyFeed::GetAuthorFeed, compact('actor', 'limit', 'cursor', 'filter'));
+        $response = $this->atp->client->get(
+            endpoint: BskyFeed::GetAuthorFeed,
+            params: compact('actor', 'limit', 'cursor', 'filter')
+        );
 
         return GetAuthorFeedResponse::fromArray($response->json());
     }
 
     public function getActorFeeds(string $actor, int $limit = 50, ?string $cursor = null): GetActorFeedsResponse
     {
-        $response = $this->atp->client->get(BskyFeed::GetActorFeeds, compact('actor', 'limit', 'cursor'));
+        $response = $this->atp->client->get(
+            endpoint: BskyFeed::GetActorFeeds,
+            params: compact('actor', 'limit', 'cursor')
+        );
 
         return GetActorFeedsResponse::fromArray($response->json());
     }
 
     public function getActorLikes(string $actor, int $limit = 50, ?string $cursor = null): GetActorLikesResponse
     {
-        $response = $this->atp->client->get(BskyFeed::GetActorLikes, compact('actor', 'limit', 'cursor'));
+        $response = $this->atp->client->get(
+            endpoint: BskyFeed::GetActorLikes,
+            params: compact('actor', 'limit', 'cursor')
+        );
 
         return GetActorLikesResponse::fromArray($response->json());
     }
 
     public function getFeed(string $feed, int $limit = 50, ?string $cursor = null): GetFeedResponse
     {
-        $response = $this->atp->client->get(BskyFeed::GetFeed, compact('feed', 'limit', 'cursor'));
+        $response = $this->atp->client->get(
+            endpoint: BskyFeed::GetFeed,
+            params: compact('feed', 'limit', 'cursor')
+        );
 
         return GetFeedResponse::fromArray($response->json());
     }
 
     public function getFeedGenerator(string $feed): GetFeedGeneratorResponse
     {
-        $response = $this->atp->client->get(BskyFeed::GetFeedGenerator, compact('feed'));
+        $response = $this->atp->client->get(
+            endpoint: BskyFeed::GetFeedGenerator,
+            params: compact('feed')
+        );
 
         return GetFeedGeneratorResponse::fromArray($response->json());
     }
 
     public function getFeedGenerators(array $feeds): GetFeedGeneratorsResponse
     {
-        $response = $this->atp->client->get(BskyFeed::GetFeedGenerators, compact('feeds'));
+        $response = $this->atp->client->get(
+            endpoint: BskyFeed::GetFeedGenerators,
+            params: compact('feeds')
+        );
 
         return GetFeedGeneratorsResponse::fromArray($response->json());
     }
 
     public function getLikes(string $uri, int $limit = 50, ?string $cursor = null, ?string $cid = null): GetLikesResponse
     {
-        $response = $this->atp->client->get(BskyFeed::GetLikes, compact('uri', 'limit', 'cursor', 'cid'));
+        $response = $this->atp->client->get(
+            endpoint: BskyFeed::GetLikes,
+            params: compact('uri', 'limit', 'cursor', 'cid')
+        );
 
         return GetLikesResponse::fromArray($response->json());
     }
 
     public function getPostThread(string $uri, int $depth = 6, int $parentHeight = 80): GetPostThreadResponse
     {
-        $response = $this->atp->client->get(BskyFeed::GetPostThread, compact('uri', 'depth', 'parentHeight'));
+        $response = $this->atp->client->get(
+            endpoint: BskyFeed::GetPostThread,
+            params: compact('uri', 'depth', 'parentHeight')
+        );
 
         return GetPostThreadResponse::fromArray($response->json());
     }
 
     public function getPosts(array $uris): GetPostsResponse
     {
-        $response = $this->atp->client->get(BskyFeed::GetPosts, compact('uris'));
+        $response = $this->atp->client->get(
+            endpoint: BskyFeed::GetPosts,
+            params: compact('uris')
+        );
 
         return GetPostsResponse::fromArray($response->json());
     }
 
     public function getQuotes(string $uri, int $limit = 50, ?string $cursor = null, ?string $cid = null): GetQuotesResponse
     {
-        $response = $this->atp->client->get(BskyFeed::GetQuotes, compact('uri', 'limit', 'cursor', 'cid'));
+        $response = $this->atp->client->get(
+            endpoint: BskyFeed::GetQuotes,
+            params: compact('uri', 'limit', 'cursor', 'cid')
+        );
 
         return GetQuotesResponse::fromArray($response->json());
     }
 
     public function getRepostedBy(string $uri, int $limit = 50, ?string $cursor = null, ?string $cid = null): GetRepostedByResponse
     {
-        $response = $this->atp->client->get(BskyFeed::GetRepostedBy, compact('uri', 'limit', 'cursor', 'cid'));
+        $response = $this->atp->client->get(
+            endpoint: BskyFeed::GetRepostedBy,
+            params: compact('uri', 'limit', 'cursor', 'cid')
+        );
 
         return GetRepostedByResponse::fromArray($response->json());
     }
 
     public function getSuggestedFeeds(int $limit = 50, ?string $cursor = null): GetSuggestedFeedsResponse
     {
-        $response = $this->atp->client->get(BskyFeed::GetSuggestedFeeds, compact('limit', 'cursor'));
+        $response = $this->atp->client->get(
+            endpoint: BskyFeed::GetSuggestedFeeds,
+            params: compact('limit', 'cursor')
+        );
 
         return GetSuggestedFeedsResponse::fromArray($response->json());
     }
 
     public function searchPosts(string $q, int $limit = 25, ?string $cursor = null, ?string $sort = null): SearchPostsResponse
     {
-        $response = $this->atp->client->get(BskyFeed::SearchPosts, compact('q', 'limit', 'cursor', 'sort'));
+        $response = $this->atp->client->get(
+            endpoint: BskyFeed::SearchPosts,
+            params: compact('q', 'limit', 'cursor', 'sort')
+        );
 
         return SearchPostsResponse::fromArray($response->json());
     }

src/Client/Public/Requests/Bsky/GraphPublicRequestClient.php

···
 {
     public function getFollowers(string $actor, int $limit = 50, ?string $cursor = null): GetFollowersResponse
     {
-        $response = $this->atp->client->get(BskyGraph::GetFollowers, compact('actor', 'limit', 'cursor'));
+        $response = $this->atp->client->get(
+            endpoint: BskyGraph::GetFollowers,
+            params: compact('actor', 'limit', 'cursor')
+        );
 
         return GetFollowersResponse::fromArray($response->json());
     }
 
     public function getFollows(string $actor, int $limit = 50, ?string $cursor = null): GetFollowsResponse
     {
-        $response = $this->atp->client->get(BskyGraph::GetFollows, compact('actor', 'limit', 'cursor'));
+        $response = $this->atp->client->get(
+            endpoint: BskyGraph::GetFollows,
+            params: compact('actor', 'limit', 'cursor')
+        );
 
         return GetFollowsResponse::fromArray($response->json());
     }
 
     public function getKnownFollowers(string $actor, int $limit = 50, ?string $cursor = null): GetKnownFollowersResponse
     {
-        $response = $this->atp->client->get(BskyGraph::GetKnownFollowers, compact('actor', 'limit', 'cursor'));
+        $response = $this->atp->client->get(
+            endpoint: BskyGraph::GetKnownFollowers,
+            params: compact('actor', 'limit', 'cursor')
+        );
 
         return GetKnownFollowersResponse::fromArray($response->json());
     }
 
     public function getList(string $list, int $limit = 50, ?string $cursor = null): GetListResponse
     {
-        $response = $this->atp->client->get(BskyGraph::GetList, compact('list', 'limit', 'cursor'));
+        $response = $this->atp->client->get(
+            endpoint: BskyGraph::GetList,
+            params: compact('list', 'limit', 'cursor')
+        );
 
         return GetListResponse::fromArray($response->json());
     }
 
     public function getLists(string $actor, int $limit = 50, ?string $cursor = null): GetListsResponse
     {
-        $response = $this->atp->client->get(BskyGraph::GetLists, compact('actor', 'limit', 'cursor'));
+        $response = $this->atp->client->get(
+            endpoint: BskyGraph::GetLists,
+            params: compact('actor', 'limit', 'cursor')
+        );
 
         return GetListsResponse::fromArray($response->json());
     }
 
     public function getRelationships(string $actor, array $others = []): GetRelationshipsResponse
     {
-        $response = $this->atp->client->get(BskyGraph::GetRelationships, compact('actor', 'others'));
+        $response = $this->atp->client->get(
+            endpoint: BskyGraph::GetRelationships,
+            params: compact('actor', 'others')
+        );
 
         return GetRelationshipsResponse::fromArray($response->json());
     }
 
     public function getStarterPack(string $starterPack): StarterPackView
     {
-        $response = $this->atp->client->get(BskyGraph::GetStarterPack, compact('starterPack'));
+        $response = $this->atp->client->get(
+            endpoint: BskyGraph::GetStarterPack,
+            params: compact('starterPack')
+        );
 
         return StarterPackView::fromArray($response->json()['starterPack']);
     }
 
     public function getStarterPacks(array $uris): GetStarterPacksResponse
     {
-        $response = $this->atp->client->get(BskyGraph::GetStarterPacks, compact('uris'));
+        $response = $this->atp->client->get(
+            endpoint: BskyGraph::GetStarterPacks,
+            params: compact('uris')
+        );
 
         return GetStarterPacksResponse::fromArray($response->json());
     }
 
     public function getSuggestedFollowsByActor(string $actor): GetSuggestedFollowsByActorResponse
     {
-        $response = $this->atp->client->get(BskyGraph::GetSuggestedFollowsByActor, compact('actor'));
+        $response = $this->atp->client->get(
+            endpoint: BskyGraph::GetSuggestedFollowsByActor,
+            params: compact('actor')
+        );
 
         return GetSuggestedFollowsByActorResponse::fromArray($response->json());
     }

src/Client/Public/Requests/Bsky/LabelerPublicRequestClient.php

···
 {
     public function getServices(array $dids, bool $detailed = false): GetServicesResponse
     {
-        $response = $this->atp->client->get(BskyLabeler::GetServices, compact('dids', 'detailed'));
+        $response = $this->atp->client->get(
+            endpoint: BskyLabeler::GetServices,
+            params: compact('dids', 'detailed')
+        );
 
         return GetServicesResponse::fromArray($response->json(), $detailed);
     }