Repository: sivchari/gotwtr
Pull request #87 (2021-11-27 11:51:54)

Refactor


Patch:
diff --git a/.golangci.yml b/.golangci.yml
index 1cb7bdb..94608bb 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -1,5 +1,5 @@
 run:
-  timeout: 5m
+  timeout: 10m
   skip-files: []
   skip-dirs: []
 
@@ -14,6 +14,8 @@ linters-settings:
     disable:
       - fieldalignment
       - shadow
+  staticcheck:
+    checks: ["all", "-S1*", "-ST1*", "-SA5011", "-SA1019", "-SA2002"]
 
 linters:
   disable-all: true
@@ -33,6 +35,7 @@ linters:
     - revive
     - staticcheck
     - varcheck
+    - unused
 
 issues:
   exclude-use-default: true
diff --git a/client.go b/client.go
index 24eeefc..038b25c 100644
--- a/client.go
+++ b/client.go
@@ -15,40 +15,56 @@ const (
 	filteredStreamRuleMaxLength = 512
 	spaceLookUpMaxIDs           = 100
 	tweetLookUpMaxIDs           = 100
-	tweetSearchMaxQueryLength   = 512
+	searchTweetMaxQueryLength   = 512
 	userLookUpMaxIDs            = 100
 )
 
-type Client interface {
+type Tweets interface {
+	RetriveMultipleTweets(ctx context.Context, tweetIDs []string, opt ...*RetriveTweetOption) (*TweetsResponse, error)
+	RetriveSingleTweet(ctx context.Context, tweetID string, opt ...*RetriveTweetOption) (*TweetResponse, error)
+	UserMentionTimeline(ctx context.Context, userID string, opt ...*UserMentionTimelineOption) (*UserMentionTimelineResponse, error)
+	UserTweetTimeline(ctx context.Context, userID string, opt ...*UserTweetTimelineOption) (*UserTweetTimelineResponse, error)
+	SearchRecentTweets(ctx context.Context, tweet string, opt ...*SearchTweetsOption) (*SearchTweetsResponse, error)
+	CountsRecentTweet(ctx context.Context, tweet string, opt ...*TweetCountsOption) (*TweetCountsResponse, error)
 	AddOrDeleteRules(ctx context.Context, body *AddOrDeleteJSONBody, opt ...*AddOrDeleteRulesOption) (*AddOrDeleteRulesResponse, error)
-	CountsRecentTweet(ctx context.Context, query string, opt ...*TweetCountsOption) (*TweetCountsResponse, error)
-	ConnectToStream(ctx context.Context, ch chan<- ConnectToStreamResponse, errCh chan<- error, opt ...*ConnectToStreamOption) *ConnectToStream
-	DiscoverSpacesByUserIDs(ctx context.Context, ids []string, opt ...*DiscoverSpacesOption) (*DiscoverSpacesByUserIDsResponse, error)
-	LookUpFollowers(ctx context.Context, id string, opt ...*FollowOption) (*FollowersResponse, error)
-	LookUpFollowing(ctx context.Context, id string, opt ...*FollowOption) (*FollowingResponse, error)
-	LookUpListByID(ctx context.Context, id string, opt ...*ListLookUpOption) (*ListLookUpByIDResponse, error)
-	LookUpListFollowersByID(ctx context.Context, id string, opt ...*ListLookUpOption) (*ListFollowersLookUpByIDResponse, error)
-	LookUpListsTweetsByID(ctx context.Context, id string, opt ...*ListLookUpOption) (*ListsTweetsLookUpByIDResponse, error)
-	ListMembers(ctx context.Context, listid string, opt ...*ListMembersOption) (*ListMembersResponse, error)
-	LookUpListsUserFollowingByID(ctx context.Context, id string, opt ...*ListLookUpOption) (*ListsUserFollowingLookUpByIDResponse, error)
-	LookUpOwnedListsByID(ctx context.Context, id string, opt ...*ListLookUpOption) (*OwnedListsLookUpByIDResponse, error)
-	LookUpSpaces(ctx context.Context, ids []string, opt ...*SpaceLookUpOption) (*SpaceLookUpResponse, error)
-	LookUpSpaceByID(ctx context.Context, id string, opt ...*SpaceLookUpOption) (*SpaceLookUpByIDResponse, error)
-	LookUpTweets(ctx context.Context, ids []string, opt ...*TweetLookUpOption) (*TweetLookUpResponse, error)
-	LookUpTweetByID(ctx context.Context, id string, opt ...*TweetLookUpOption) (*TweetLookUpByIDResponse, error)
-	LookUpUsers(ctx context.Context, ids []string, opt ...*UserLookUpOption) (*UserLookUpResponse, error)
-	LookUpUserByID(ctx context.Context, id string, opt ...*UserLookUpOption) (*UserLookUpByIDResponse, error)
-	LookUpUserByUserName(ctx context.Context, name string, opt ...*UserLookUpOption) (*UserLookUpByUserNameResponse, error)
-	LookUpUsersByUserNames(ctx context.Context, names []string, opt ...*UserLookUpOption) (*UsersLookUpByUserNamesResponse, error)
-	LookUpUsersWhoLiked(ctx context.Context, tweetID string, opt ...*LookUpUsersWhoLikedOpts) (*LookUpUsersWhoLikedResponse, error)
-	LookUpUsersWhoPurchasedSpaceTicket(ctx context.Context, id string, opt ...*LookUpUsersWhoPurchasedSpaceTicketOption) (*LookUpUsersWhoPurchasedSpaceTicketResponse, error)
 	RetrieveStreamRules(ctx context.Context, opt ...*RetrieveStreamRulesOption) (*RetrieveStreamRulesResponse, error)
-	RetweetsLookup(ctx context.Context, id string, opt ...*RetweetsLookupOpts) (*RetweetsLookupResponse, error)
-	SampledStream(ctx context.Context, ch chan<- SampledStreamResponse, errCh chan<- error, opt ...*SampledStreamOpts) *StreamResponse
-	SearchRecentTweets(ctx context.Context, query string, opt ...*TweetSearchOption) (*TweetSearchResponse, error)
-	SearchSpaces(ctx context.Context, query string, opt ...*SearchSpacesOption) (*SearchSpacesResponse, error)
-	UserMentionTimeline(ctx context.Context, id string, opt ...*UserMentionTimelineOption) (*UserMentionTimelineResponse, error)
-	UserTweetTimeline(ctx context.Context, id string, opt ...*UserTweetTimelineOption) (*UserTweetTimelineResponse, error)
+	ConnectToStream(ctx context.Context, ch chan<- ConnectToStreamResponse, errCh chan<- error, opt ...*ConnectToStreamOption) *ConnectToStream
+	VolumeStreams(ctx context.Context, ch chan<- VolumeStreamsResponse, errCh chan<- error, opt ...*VolumeStreamsOption) *VolumeStreams
+	RetweetsLookup(ctx context.Context, tweetID string, opt ...*RetweetsLookupOption) (*RetweetsResponse, error)
+	UsersLikingTweet(ctx context.Context, tweetID string, opt ...*UsersLikingTweetOption) (*UsersLikingTweetResponse, error)
+}
+
+type Users interface {
+	RetrieveMultipleUsersWithIDs(ctx context.Context, userIDs []string, opt ...*RetrieveUserOption) (*UsersResponse, error)
+	RetrieveSingleUserWithID(ctx context.Context, userID string, opt ...*RetrieveUserOption) (*UserResponse, error)
+	RetrieveMultipleUsersWithUserNames(ctx context.Context, userNames []string, opt ...*RetrieveUserOption) (*UsersResponse, error)
+	RetrieveSingleUserWithUserName(ctx context.Context, userName string, opt ...*RetrieveUserOption) (*UserResponse, error)
+	Followers(ctx context.Context, userID string, opt ...*FollowOption) (*FollowersResponse, error)
+	Following(ctx context.Context, userID string, opt ...*FollowOption) (*FollowingResponse, error)
+}
+
+type Spaces interface {
+	LookUpSpace(ctx context.Context, spaceID string, opt ...*SpaceOption) (*SpaceResponse, error)
+	LookUpSpaces(ctx context.Context, spaceIDs []string, opt ...*SpaceOption) (*SpacesResponse, error)
+	UsersPurchasedSpaceTicket(ctx context.Context, spaceID string, opt ...*UsersPurchasedSpaceTicketOption) (*UsersPurchasedSpaceTicketResponse, error)
+	DiscoverSpaces(ctx context.Context, userIDs []string, opt ...*DiscoverSpacesOption) (*DiscoverSpacesResponse, error)
+	SearchSpaces(ctx context.Context, searchTerm string, opt ...*SearchSpacesOption) (*SearchSpacesResponse, error)
+}
+
+type Lists interface {
+	LookUpList(ctx context.Context, listID string, opt ...*LookUpListOption) (*ListResponse, error)
+	LookUpAllListsOwned(ctx context.Context, userID string, opt ...*AllListsOwnedOption) (*AllListsOwnedResponse, error)
+	LookUpListTweets(ctx context.Context, listID string, opt ...*ListTweetsOption) (*ListTweetsResponse, error)
+	ListMembers(ctx context.Context, listID string, opt ...*ListMembersOption) (*ListMembersResponse, error)
+	LookUpListFollowers(ctx context.Context, listID string, opt ...*ListFollowersOption) (*ListFollowersResponse, error)
+	LookUpAllListsUserFollows(ctx context.Context, userID string, opt ...*ListFollowsOption) (*AllListsUserFollowsResponse, error)
+}
+
+type Client interface {
+	Tweets
+	Users
+	Spaces
+	Lists
 }
 
 var _ Client = (*client)(nil)
@@ -74,118 +90,117 @@ func WithHTTPClient(httpClient *http.Client) ClientOption {
 	}
 }
 
-func (c *client) AddOrDeleteRules(ctx context.Context, body *AddOrDeleteJSONBody, opt ...*AddOrDeleteRulesOption) (*AddOrDeleteRulesResponse, error) {
-	return addOrDeleteRules(ctx, c, body, opt...)
+func (c *client) RetriveMultipleTweets(ctx context.Context, tweetIDs []string, opt ...*RetriveTweetOption) (*TweetsResponse, error) {
+	return retrieveMultipleTweets(ctx, c, tweetIDs, opt...)
 }
 
-func (c *client) CountsRecentTweet(ctx context.Context, query string, opt ...*TweetCountsOption) (*TweetCountsResponse, error) {
-	return countsRecentTweet(ctx, c, query, opt...)
+func (c *client) RetriveSingleTweet(ctx context.Context, tweetID string, opt ...*RetriveTweetOption) (*TweetResponse, error) {
+	return retrieveSingleTweet(ctx, c, tweetID, opt...)
 }
 
-func (c *client) ConnectToStream(ctx context.Context, ch chan<- ConnectToStreamResponse, errCh chan<- error, opt ...*ConnectToStreamOption) *ConnectToStream {
-	return connectToStream(ctx, c, ch, errCh, opt...)
+func (c *client) UserMentionTimeline(ctx context.Context, userID string, opt ...*UserMentionTimelineOption) (*UserMentionTimelineResponse, error) {
+	return userMentionTimeline(ctx, c, userID, opt...)
 }
 
-func (c *client) DiscoverSpacesByUserIDs(ctx context.Context, ids []string, opt ...*DiscoverSpacesOption) (*DiscoverSpacesByUserIDsResponse, error) {
-	return discoverSpacesByUserIDs(ctx, c, ids, opt...)
+func (c *client) UserTweetTimeline(ctx context.Context, userID string, opt ...*UserTweetTimelineOption) (*UserTweetTimelineResponse, error) {
+	return userTweetTimeline(ctx, c, userID, opt...)
 }
 
-func (c *client) LookUpFollowers(ctx context.Context, id string, opt ...*FollowOption) (*FollowersResponse, error) {
-	return lookUpFollowers(ctx, c, id, opt...)
+func (c *client) SearchRecentTweets(ctx context.Context, tweet string, opt ...*SearchTweetsOption) (*SearchTweetsResponse, error) {
+	return searchRecentTweets(ctx, c, tweet, opt...)
 }
 
-func (c *client) LookUpFollowing(ctx context.Context, id string, opt ...*FollowOption) (*FollowingResponse, error) {
-	return lookUpFollowing(ctx, c, id, opt...)
+func (c *client) CountsRecentTweet(ctx context.Context, tweet string, opt ...*TweetCountsOption) (*TweetCountsResponse, error) {
+	return countsRecentTweet(ctx, c, tweet, opt...)
 }
 
-func (c *client) LookUpListByID(ctx context.Context, id string, opt ...*ListLookUpOption) (*ListLookUpByIDResponse, error) {
-	return lookUpListByID(ctx, c, id, opt...)
+func (c *client) AddOrDeleteRules(ctx context.Context, body *AddOrDeleteJSONBody, opt ...*AddOrDeleteRulesOption) (*AddOrDeleteRulesResponse, error) {
+	return addOrDeleteRules(ctx, c, body, opt...)
 }
 
-func (c *client) LookUpListFollowersByID(ctx context.Context, id string, opt ...*ListLookUpOption) (*ListFollowersLookUpByIDResponse, error) {
-	return lookUpListFollowersByID(ctx, c, id, opt...)
+func (c *client) RetrieveStreamRules(ctx context.Context, opt ...*RetrieveStreamRulesOption) (*RetrieveStreamRulesResponse, error) {
+	return retrieveStreamRules(ctx, c, opt...)
 }
 
-func (c *client) LookUpListsTweetsByID(ctx context.Context, id string, opt ...*ListLookUpOption) (*ListsTweetsLookUpByIDResponse, error) {
-	return lookUpListsTweetsByID(ctx, c, id, opt...)
+func (c *client) ConnectToStream(ctx context.Context, ch chan<- ConnectToStreamResponse, errCh chan<- error, opt ...*ConnectToStreamOption) *ConnectToStream {
+	return connectToStream(ctx, c, ch, errCh, opt...)
 }
 
-func (c *client) ListMembers(ctx context.Context, listid string, opt ...*ListMembersOption) (*ListMembersResponse, error) {
-	return listMembers(ctx, c, listid, opt...)
+func (c *client) VolumeStreams(ctx context.Context, ch chan<- VolumeStreamsResponse, errCh chan<- error, opt ...*VolumeStreamsOption) *VolumeStreams {
+	return volumeStreams(ctx, c, ch, errCh, opt...)
 }
 
-func (c *client) LookUpListsUserFollowingByID(ctx context.Context, id string, opt ...*ListLookUpOption) (*ListsUserFollowingLookUpByIDResponse, error) {
-	return lookUpListsUserFollowingByID(ctx, c, id, opt...)
+func (c *client) RetweetsLookup(ctx context.Context, tweetID string, opt ...*RetweetsLookupOption) (*RetweetsResponse, error) {
+	return retweetsLookup(ctx, c, tweetID, opt...)
 }
 
-func (c *client) LookUpOwnedListsByID(ctx context.Context, id string, opt ...*ListLookUpOption) (*OwnedListsLookUpByIDResponse, error) {
-	return lookUpOwnedListsByID(ctx, c, id, opt...)
+func (c *client) UsersLikingTweet(ctx context.Context, tweetID string, opt ...*UsersLikingTweetOption) (*UsersLikingTweetResponse, error) {
+	return usersLikingTweet(ctx, c, tweetID, opt...)
 }
 
-func (c *client) LookUpSpaces(ctx context.Context, ids []string, opt ...*SpaceLookUpOption) (*SpaceLookUpResponse, error) {
-	return lookUpSpaces(ctx, c, ids, opt...)
+func (c *client) RetrieveMultipleUsersWithIDs(ctx context.Context, userIDs []string, opt ...*RetrieveUserOption) (*UsersResponse, error) {
+	return retrieveMultipleUsersWithIDs(ctx, c, userIDs, opt...)
 }
 
-func (c *client) LookUpSpaceByID(ctx context.Context, id string, opt ...*SpaceLookUpOption) (*SpaceLookUpByIDResponse, error) {
-	return lookUpSpaceByID(ctx, c, id, opt...)
+func (c *client) RetrieveSingleUserWithID(ctx context.Context, userID string, opt ...*RetrieveUserOption) (*UserResponse, error) {
+	return retrieveSingleUserWithID(ctx, c, userID, opt...)
 }
 
-func (c *client) LookUpUsersWhoPurchasedSpaceTicket(ctx context.Context, id string, opt ...*LookUpUsersWhoPurchasedSpaceTicketOption) (*LookUpUsersWhoPurchasedSpaceTicketResponse, error) {
-	return lookUpUsersWhoPurchasedSpaceTicket(ctx, c, id, opt...)
+func (c *client) RetrieveMultipleUsersWithUserNames(ctx context.Context, userNames []string, opt ...*RetrieveUserOption) (*UsersResponse, error) {
+	return retrieveMultipleUsersWithUserNames(ctx, c, userNames, opt...)
 }
 
-func (c *client) LookUpTweets(ctx context.Context, ids []string, opt ...*TweetLookUpOption) (*TweetLookUpResponse, error) {
-	return lookUpTweets(ctx, c, ids, opt...)
+func (c *client) RetrieveSingleUserWithUserName(ctx context.Context, userName string, opt ...*RetrieveUserOption) (*UserResponse, error) {
+	return retrieveSingleUserWithUserName(ctx, c, userName, opt...)
 }
 
-func (c *client) LookUpTweetByID(ctx context.Context, id string, opt ...*TweetLookUpOption) (*TweetLookUpByIDResponse, error) {
-	return lookUpTweetByID(ctx, c, id, opt...)
+func (c *client) Followers(ctx context.Context, userID string, opt ...*FollowOption) (*FollowersResponse, error) {
+	return followers(ctx, c, userID, opt...)
 }
 
-func (c *client) LookUpUsers(ctx context.Context, ids []string, opt ...*UserLookUpOption) (*UserLookUpResponse, error) {
-	return lookUpUsers(ctx, c, ids, opt...)
+func (c *client) Following(ctx context.Context, userID string, opt ...*FollowOption) (*FollowingResponse, error) {
+	return following(ctx, c, userID, opt...)
 }
 
-func (c *client) LookUpUserByID(ctx context.Context, id string, opt ...*UserLookUpOption) (*UserLookUpByIDResponse, error) {
-	return lookUpUserByID(ctx, c, id, opt...)
+func (c *client) LookUpSpace(ctx context.Context, spaceID string, opt ...*SpaceOption) (*SpaceResponse, error) {
+	return lookUpSpace(ctx, c, spaceID, opt...)
 }
 
-func (c *client) LookUpUserByUserName(ctx context.Context, name string, opt ...*UserLookUpOption) (*UserLookUpByUserNameResponse, error) {
-	return lookUpUserByUserName(ctx, c, name, opt...)
+func (c *client) LookUpSpaces(ctx context.Context, spaceIDs []string, opt ...*SpaceOption) (*SpacesResponse, error) {
+	return lookUpSpaces(ctx, c, spaceIDs, opt...)
 }
 
-func (c *client) LookUpUsersByUserNames(ctx context.Context, names []string, opt ...*UserLookUpOption) (*UsersLookUpByUserNamesResponse, error) {
-	return lookUpUsersByUserNames(ctx, c, names, opt...)
+func (c *client) UsersPurchasedSpaceTicket(ctx context.Context, spaceID string, opt ...*UsersPurchasedSpaceTicketOption) (*UsersPurchasedSpaceTicketResponse, error) {
+	return usersPurchasedSpaceTicket(ctx, c, spaceID, opt...)
 }
-
-func (c *client) LookUpUsersWhoLiked(ctx context.Context, tweetID string, opt ...*LookUpUsersWhoLikedOpts) (*LookUpUsersWhoLikedResponse, error) {
-	return lookUpUsersWhoLiked(ctx, c, tweetID, opt...)
+func (c *client) DiscoverSpaces(ctx context.Context, userIDs []string, opt ...*DiscoverSpacesOption) (*DiscoverSpacesResponse, error) {
+	return discoverSpaces(ctx, c, userIDs, opt...)
 }
 
-func (c *client) RetrieveStreamRules(ctx context.Context, opt ...*RetrieveStreamRulesOption) (*RetrieveStreamRulesResponse, error) {
-	return retrieveStreamRules(ctx, c, opt...)
+func (c *client) SearchSpaces(ctx context.Context, searchTerm string, opt ...*SearchSpacesOption) (*SearchSpacesResponse, error) {
+	return searchSpaces(ctx, c, searchTerm, opt...)
 }
 
-func (c *client) RetweetsLookup(ctx context.Context, id string, opt ...*RetweetsLookupOpts) (*RetweetsLookupResponse, error) {
-	return retweetsLookup(ctx, c, id, opt...)
+func (c *client) LookUpList(ctx context.Context, listID string, opt ...*LookUpListOption) (*ListResponse, error) {
+	return lookUpList(ctx, c, listID, opt...)
 }
 
-func (c *client) SampledStream(ctx context.Context, ch chan<- SampledStreamResponse, errCh chan<- error, opt ...*SampledStreamOpts) *StreamResponse {
-	return sampledStream(ctx, c, ch, errCh, opt...)
+func (c *client) LookUpAllListsOwned(ctx context.Context, userID string, opt ...*AllListsOwnedOption) (*AllListsOwnedResponse, error) {
+	return lookUpAllListsOwned(ctx, c, userID, opt...)
 }
 
-func (c *client) SearchRecentTweets(ctx context.Context, query string, opt ...*TweetSearchOption) (*TweetSearchResponse, error) {
-	return searchRecentTweets(ctx, c, query, opt...)
+func (c *client) LookUpListTweets(ctx context.Context, listID string, opt ...*ListTweetsOption) (*ListTweetsResponse, error) {
+	return lookUpListTweets(ctx, c, listID, opt...)
 }
 
-func (c *client) SearchSpaces(ctx context.Context, query string, opt ...*SearchSpacesOption) (*SearchSpacesResponse, error) {
-	return searchSpaces(ctx, c, query, opt...)
+func (c *client) ListMembers(ctx context.Context, listid string, opt ...*ListMembersOption) (*ListMembersResponse, error) {
+	return listMembers(ctx, c, listid, opt...)
 }
 
-func (c *client) UserMentionTimeline(ctx context.Context, id string, opt ...*UserMentionTimelineOption) (*UserMentionTimelineResponse, error) {
-	return userMentionTimeline(ctx, c, id, opt...)
+func (c *client) LookUpListFollowers(ctx context.Context, listID string, opt ...*ListFollowersOption) (*ListFollowersResponse, error) {
+	return lookUpListFollowers(ctx, c, listID, opt...)
 }
 
-func (c *client) UserTweetTimeline(ctx context.Context, id string, opt ...*UserTweetTimelineOption) (*UserTweetTimelineResponse, error) {
-	return userTweetTimeline(ctx, c, id, opt...)
+func (c *client) LookUpAllListsUserFollows(ctx context.Context, userID string, opt ...*ListFollowsOption) (*AllListsUserFollowsResponse, error) {
+	return lookUpAllListsUserFollows(ctx, c, userID, opt...)
 }
diff --git a/discover_spaces.go b/discover_spaces.go
index 0642b49..17052ef 100644
--- a/discover_spaces.go
+++ b/discover_spaces.go
@@ -8,29 +8,26 @@ import (
 	"net/http"
 )
 
-func discoverSpacesByUserIDs(ctx context.Context, c *client, ids []string, opt ...*DiscoverSpacesOption) (*DiscoverSpacesByUserIDsResponse, error) {
-	// check ids
+func discoverSpaces(ctx context.Context, c *client, userIDs []string, opt ...*DiscoverSpacesOption) (*DiscoverSpacesResponse, error) {
 	switch {
-	case len(ids) == 0:
+	case len(userIDs) == 0:
 		return nil, errors.New("discover spaces: ids parameter is required")
-	case len(ids) > discoverSpacesMaxIDs:
+	case len(userIDs) > discoverSpacesMaxIDs:
 		return nil, errors.New("discover spaces: ids parameter must be less than or equal to 100")
 	default:
 	}
-
-	spaceDiscover := spaceDiscover + "?user_ids="
-	// join ids to url
-	for i, id := range ids {
-		if i+1 < len(ids) {
-			spaceDiscover += fmt.Sprintf("%s,", id)
+	ep := discoverSpacesURL
+	for i, uid := range userIDs {
+		if i+1 < len(userIDs) {
+			ep += fmt.Sprintf("%s,", uid)
 		} else {
-			spaceDiscover += id
+			ep += uid
 		}
 	}
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, spaceDiscover, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep, nil)
 	if err != nil {
-		return nil, fmt.Errorf("discover spaces new request with ctx: %w", err)
+		return nil, fmt.Errorf("discover spaces: %w", err)
 	}
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
 
@@ -51,14 +48,14 @@ func discoverSpacesByUserIDs(ctx context.Context, c *client, ids []string, opt .
 	}
 	defer resp.Body.Close()
 
-	var dsr DiscoverSpacesByUserIDsResponse
+	var dsr DiscoverSpacesResponse
 
 	if err := json.NewDecoder(resp.Body).Decode(&dsr); err != nil {
 		return nil, fmt.Errorf("discover spaces: %w", err)
 	}
 
 	if resp.StatusCode != http.StatusOK {
-		return nil, &HTTPError{
+		return &dsr, &HTTPError{
 			APIName: "discover spaces",
 			Status:  resp.Status,
 			URL:     req.URL.String(),
diff --git a/endpoint.go b/endpoint.go
index 0a78028..7d58667 100644
--- a/endpoint.go
+++ b/endpoint.go
@@ -2,25 +2,42 @@ package gotwtr
 
 // EndpointURL is the base URL for the Twitter V2 API.
 const (
-	filteredStream           = "https://api.twitter.com/2/tweets/search/stream"
-	followingLookUp          = "https://api.twitter.com/2/users"
-	followersLookUp          = "https://api.twitter.com/2/users"
-	listLookUp               = "https://api.twitter.com/2/lists"
-	listFollowersLookUp      = "https://api.twitter.com/2/lists"
-	listMembersURL           = "https://api.twitter.com/2/lists/%v/members"
-	listsTweetsLookUp        = "https://api.twitter.com/2/lists"
-	listsUserFollowingLookUp = "https://api.twitter.com/2/users"
-	likesLookUpUsers         = "https://api.twitter.com/2/tweets"
-	ownedListLookUp          = "https://api.twitter.com/2/users"
-	recentTweetCounts        = "https://api.twitter.com/2/tweets/counts/recent"
-	retweet                  = "https://api.twitter.com/2/tweets"
-	sampleStream             = "https://api.twitter.com/2/tweets/sample/stream"
-	spaceDiscover            = "https://api.twitter.com/2/spaces/by/creator_ids"
-	spaceLookUp              = "https://api.twitter.com/2/spaces"
-	spaceLookUpBuyers        = "https://api.twitter.com/2/spaces"
-	spacesSearch             = "https://api.twitter.com/2/spaces/search"
-	timeline                 = "https://api.twitter.com/2/users"
-	tweetLookUp              = "https://api.twitter.com/2/tweets"
-	tweetRecentSearch        = "https://api.twitter.com/2/tweets/search/recent"
-	userLookUp               = "https://api.twitter.com/2/users"
+	retrieveMultipleTweetsURL = "https://api.twitter.com/2/tweets?ids="
+	retrieveSingleTweetURL    = "https://api.twitter.com/2/tweets/%v"
+	userTweetTimelineURL      = "https://api.twitter.com/2/users/%v/tweets"
+	userMentionTimelineURL    = "https://api.twitter.com/2/users/%v/mentions"
+	searchRecentTweetsURL     = "https://api.twitter.com/2/tweets/search/recent?query=%v"
+	countsRecentTweetsURL     = "https://api.twitter.com/2/tweets/counts/recent?query=%v"
+	addOrDeleteRulesURL       = "https://api.twitter.com/2/tweets/search/stream/rules"
+	retrieveStreamRulesURL    = "https://api.twitter.com/2/tweets/search/stream/rules"
+	connectToStreamURL        = "https://api.twitter.com/2/tweets/search/stream"
+	volumeStreamsURL          = "https://api.twitter.com/2/tweets/sample/stream"
+	retweetsLookupURL         = "https://api.twitter.com/2/tweets/%v/retweeted_by"
+	usersLikingTweetURL       = "https://api.twitter.com/2/tweets/%v/liking_users"
+)
+
+const (
+	retrieveMultipleUsersWithIDsURL       = "https://api.twitter.com/2/users?ids="
+	retrieveSingleUserWithIDURL           = "https://api.twitter.com/2/users/%v"
+	retrieveMultipleUsersWithUserNamesURL = "https://api.twitter.com/2/users/by?usernames="
+	retrieveSingleUserWithUserNameURL     = "https://api.twitter.com/2/users/by/username/%v"
+	followingURL                          = "https://api.twitter.com/2/users/%v/following"
+	followersURL                          = "https://api.twitter.com/2/users/%v/followers"
+)
+
+const (
+	spaceURL                     = "https://api.twitter.com/2/spaces/%v"
+	spacesURL                    = "https://api.twitter.com/2/spaces?ids="
+	usersPurchasedSpaceTicketURL = "https://api.twitter.com/2/spaces/%v/buyers"
+	discoverSpacesURL            = "https://api.twitter.com/2/spaces/by/creator_ids?user_ids="
+	searchSpacesURL              = "https://api.twitter.com/2/spaces/search?query=%v"
+)
+
+const (
+	lookUpListURL                = "https://api.twitter.com/2/lists/%v"
+	lookUpAllListsOwnedURL       = "https://api.twitter.com/2/users/%v/owned_lists"
+	lookUpListTweetsURL          = "https://api.twitter.com/2/lists/%v/tweets"
+	listMembersURL               = "https://api.twitter.com/2/lists/%v/members"
+	lookUpListFollowersURL       = "https://api.twitter.com/2/lists/%v/followers"
+	lookUpAllListsUserFollowsURL = "https://api.twitter.com/2/users/%v/followed_lists"
 )
diff --git a/example/list/follows/main.go b/example/list/follows/main.go
index c6520d5..1e38049 100644
--- a/example/list/follows/main.go
+++ b/example/list/follows/main.go
@@ -10,7 +10,7 @@ import (
 func main() {
 	client := gotwtr.New("key")
 	// look up list followers by id
-	us, err := client.LookUpListFollowersByID(context.Background(), "id")
+	us, err := client.LookUpListFollowers(context.Background(), "id")
 	if err != nil {
 		panic(err)
 	}
@@ -19,7 +19,7 @@ func main() {
 	}
 
 	// look up lists user following by ID
-	ls, err := client.LookUpListsUserFollowingByID(context.Background(), "id")
+	ls, err := client.LookUpAllListsUserFollows(context.Background(), "id")
 	if err != nil {
 		panic(err)
 	}
diff --git a/example/list/lookup/main.go b/example/list/lookup/main.go
index 4804f6f..4e5fe9a 100644
--- a/example/list/lookup/main.go
+++ b/example/list/lookup/main.go
@@ -10,7 +10,7 @@ import (
 func main() {
 	client := gotwtr.New("key")
 	// look up owned lists by id
-	ls, err := client.LookUpOwnedListsByID(context.Background(), "id")
+	ls, err := client.LookUpAllListsOwned(context.Background(), "id")
 	if err != nil {
 		panic(err)
 	}
@@ -19,7 +19,7 @@ func main() {
 	}
 
 	// look up list by ID
-	l, err := client.LookUpListByID(context.Background(), "id")
+	l, err := client.LookUpList(context.Background(), "id")
 	if err != nil {
 		panic(err)
 	}
diff --git a/example/list/tweetslookup/main.go b/example/list/tweetslookup/main.go
index 5a32964..7b27cdd 100644
--- a/example/list/tweetslookup/main.go
+++ b/example/list/tweetslookup/main.go
@@ -10,7 +10,7 @@ import (
 func main() {
 	client := gotwtr.New("key")
 	// look up lists tweets by id
-	ts, err := client.LookUpListsTweetsByID(context.Background(), "id")
+	ts, err := client.LookUpListTweets(context.Background(), "id")
 	if err != nil {
 		panic(err)
 	}
diff --git a/example/space/discover/main.go b/example/space/discover/main.go
index a08ac0a..7a9fdf9 100644
--- a/example/space/discover/main.go
+++ b/example/space/discover/main.go
@@ -9,13 +9,12 @@ import (
 
 func main() {
 	client := gotwtr.New("key")
-	dsr, err := client.DiscoverSpacesByUserIDs(context.Background(), []string{"id"}, &gotwtr.DiscoverSpacesOption{
+	dsr, err := client.DiscoverSpaces(context.Background(), []string{"id"}, &gotwtr.DiscoverSpacesOption{
 		Expansions: []gotwtr.Expansion{
 			gotwtr.ExpansionHostIDs,
 			gotwtr.ExpansionCreatorID,
 			gotwtr.ExpansionInvitedUserIDs,
 			gotwtr.ExpansionSpeakerIDs,
-			gotwtr.ExpansionTopicIDs,
 		},
 		TopicFields: []gotwtr.TopicField{
 			gotwtr.TopicFieldName,
diff --git a/example/space/lookup/main.go b/example/space/lookup/main.go
index 67e9598..504d812 100644
--- a/example/space/lookup/main.go
+++ b/example/space/lookup/main.go
@@ -11,7 +11,7 @@ func main() {
 	client := gotwtr.New("key")
 
 	// look up by ID
-	s, err := client.LookUpSpaceByID(context.Background(), "spaceid")
+	s, err := client.LookUpSpace(context.Background(), "spaceid")
 	if err != nil {
 		panic(err)
 	}
@@ -29,7 +29,7 @@ func main() {
 		fmt.Printf("index: %d, val: %v\n", i, s)
 	}
 
-	str, err := client.LookUpUsersWhoPurchasedSpaceTicket(context.Background(), "spaceid")
+	str, err := client.UsersPurchasedSpaceTicket(context.Background(), "spaceid")
 	if err != nil {
 		panic(err)
 	}
diff --git a/example/tweet/likes/main.go b/example/tweet/likes/main.go
index 5dc9b51..796631c 100644
--- a/example/tweet/likes/main.go
+++ b/example/tweet/likes/main.go
@@ -10,7 +10,7 @@ import (
 func main() {
 	client := gotwtr.New("key")
 	// get users who liked the tweet that id is "tweet_id"
-	t, err := client.LookUpUsersWhoLiked(context.Background(), "tweet_id")
+	t, err := client.UsersLikingTweet(context.Background(), "tweet_id")
 	if err != nil {
 		panic(err)
 	}
@@ -20,7 +20,7 @@ func main() {
 	}
 
 	// get users who liked the tweet that id is "tweet_id" with option
-	t, err = client.LookUpUsersWhoLiked(context.Background(), "tweet_id", &gotwtr.LookUpUsersWhoLikedOpts{
+	t, err = client.UsersLikingTweet(context.Background(), "tweet_id", &gotwtr.UsersLikingTweetOption{
 		Expansions:  []gotwtr.Expansion{gotwtr.ExpansionPinnedTweetID},
 		UserFields:  []gotwtr.UserField{gotwtr.UserFieldCreatedAt},
 		TweetFields: []gotwtr.TweetField{gotwtr.TweetFieldCreatedAt},
diff --git a/example/tweet/lookup/main.go b/example/tweet/lookup/main.go
index 8296bc8..601bf6b 100644
--- a/example/tweet/lookup/main.go
+++ b/example/tweet/lookup/main.go
@@ -10,7 +10,7 @@ import (
 func main() {
 	client := gotwtr.New("key")
 	// look up
-	ts, err := client.LookUpTweets(context.Background(), []string{"id", "id2"})
+	ts, err := client.RetriveMultipleTweets(context.Background(), []string{"id", "id2"})
 	if err != nil {
 		panic(err)
 	}
@@ -19,7 +19,7 @@ func main() {
 	}
 
 	// look up by ID
-	t, err := client.LookUpTweetByID(context.Background(), "id")
+	t, err := client.RetriveSingleTweet(context.Background(), "id")
 	if err != nil {
 		panic(err)
 	}
diff --git a/example/tweet/search/main.go b/example/tweet/search/main.go
index c5ec0e8..6763115 100644
--- a/example/tweet/search/main.go
+++ b/example/tweet/search/main.go
@@ -9,7 +9,7 @@ import (
 
 func main() {
 	client := gotwtr.New("key")
-	tsr, err := client.SearchRecentTweets(context.Background(), "go", &gotwtr.TweetSearchOption{
+	tsr, err := client.SearchRecentTweets(context.Background(), "go", &gotwtr.SearchTweetsOption{
 		TweetFields: []gotwtr.TweetField{
 			gotwtr.TweetFieldAuthorID,
 			gotwtr.TweetFieldAttachments,
diff --git a/example/tweet/stream/main.go b/example/tweet/stream/main.go
index e990a9f..2bf4f20 100644
--- a/example/tweet/stream/main.go
+++ b/example/tweet/stream/main.go
@@ -11,9 +11,9 @@ import (
 func main() {
 	client := gotwtr.New("key")
 	// sampled stream
-	ch := make(chan gotwtr.SampledStreamResponse, 5)
+	ch := make(chan gotwtr.VolumeStreamsResponse, 5)
 	errCh := make(chan error)
-	stream := client.SampledStream(context.Background(), ch, errCh)
+	stream := client.VolumeStreams(context.Background(), ch, errCh)
 	fmt.Println("streaming...")
 	done := make(chan struct{})
 	go func(done chan struct{}) {
diff --git a/example/user/follow/main.go b/example/user/follow/main.go
index 8b34500..24be2f4 100644
--- a/example/user/follow/main.go
+++ b/example/user/follow/main.go
@@ -10,7 +10,7 @@ import (
 func main() {
 	client := gotwtr.New("key")
 
-	followingUsers, err := client.LookUpFollowing(context.Background(), "id", &gotwtr.FollowOption{
+	followingUsers, err := client.Following(context.Background(), "id", &gotwtr.FollowOption{
 		MaxResults: 10,
 	})
 	if err != nil {
@@ -20,7 +20,7 @@ func main() {
 		fmt.Println(u)
 	}
 
-	followerUsers, err := client.LookUpFollowers(context.Background(), "id")
+	followerUsers, err := client.Followers(context.Background(), "id")
 	if err != nil {
 		panic(err)
 	}
diff --git a/example/user/lookup/main.go b/example/user/lookup/main.go
index 6a79f64..a816f84 100644
--- a/example/user/lookup/main.go
+++ b/example/user/lookup/main.go
@@ -10,7 +10,7 @@ import (
 func main() {
 	client := gotwtr.New("key")
 	// look up users
-	us, err := client.LookUpUsers(context.Background(), []string{"id", "id2"})
+	us, err := client.RetrieveMultipleUsersWithIDs(context.Background(), []string{"id", "id2"})
 	if err != nil {
 		panic(err)
 	}
@@ -19,14 +19,14 @@ func main() {
 	}
 
 	// look up user by ID
-	u, err := client.LookUpUserByID(context.Background(), "id")
+	u, err := client.RetrieveSingleUserWithID(context.Background(), "id")
 	if err != nil {
 		panic(err)
 	}
 	fmt.Println(*u.User)
 
 	// look up users by username
-	uns, err := client.LookUpUsersByUserNames(context.Background(), []string{"username", "username2"})
+	uns, err := client.RetrieveMultipleUsersWithUserNames(context.Background(), []string{"username", "username2"})
 	if err != nil {
 		panic(err)
 	}
@@ -35,7 +35,7 @@ func main() {
 	}
 
 	// look up user by username
-	un, err := client.LookUpUserByUserName(context.Background(), "username")
+	un, err := client.RetrieveSingleUserWithUserName(context.Background(), "username")
 	if err != nil {
 		panic(err)
 	}
diff --git a/expansion.go b/expansion.go
index b210c08..81546fd 100644
--- a/expansion.go
+++ b/expansion.go
@@ -19,7 +19,6 @@ const (
 	ExpansionContextAnnotations         Expansion = "context_annotations"
 	ExpansionTopicIDs                   Expansion = "topic_ids"
 	ExpansionOwnerID                    Expansion = "list.owner_id"
-	// ExpansionTopics                     Expansion = "topics" TODO: must check
 )
 
 func expansionsToString(es []Expansion) []string {
diff --git a/filtered_stream.go b/filtered_stream.go
index 5226a11..68d0056 100644
--- a/filtered_stream.go
+++ b/filtered_stream.go
@@ -11,50 +11,7 @@ import (
 	"sync"
 )
 
-func retrieveStreamRules(ctx context.Context, c *client, opt ...*RetrieveStreamRulesOption) (*RetrieveStreamRulesResponse, error) {
-	filteredStreamRules := filteredStream + "/rules"
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, filteredStreamRules, nil)
-	if err != nil {
-		return nil, fmt.Errorf("retrieve stream rules new request with ctx: %w", err)
-	}
-	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
-
-	var topt RetrieveStreamRulesOption
-	switch len(opt) {
-	case 0:
-		// do nothing
-	case 1:
-		topt = *opt[0]
-	default:
-		return nil, errors.New("retrieve stream rules: only one option is allowed")
-	}
-	topt.addQuery(req)
-
-	resp, err := c.client.Do(req)
-	if err != nil {
-		return nil, fmt.Errorf("retrieve stream rules: %w", err)
-	}
-	defer resp.Body.Close()
-
-	var tweet RetrieveStreamRulesResponse
-	if err := json.NewDecoder(resp.Body).Decode(&tweet); err != nil {
-		return nil, fmt.Errorf("retrieve stream rules decode: %w", err)
-	}
-	if resp.StatusCode != http.StatusOK {
-		return &tweet, &HTTPError{
-			APIName: "retrieve stream rules",
-			Status:  resp.Status,
-			URL:     req.URL.String(),
-		}
-	}
-
-	return &tweet, nil
-}
-
 func addOrDeleteRules(ctx context.Context, c *client, body *AddOrDeleteJSONBody, opt ...*AddOrDeleteRulesOption) (*AddOrDeleteRulesResponse, error) {
-	filteredStreamRules := filteredStream + "/rules"
-
 	switch {
 	case len(body.Add) == 0 && len(body.Delete.IDs) == 0:
 		return nil, errors.New("add or delete rules: add or delete.ids are required")
@@ -76,7 +33,7 @@ func addOrDeleteRules(ctx context.Context, c *client, body *AddOrDeleteJSONBody,
 		return nil, errors.New("add or delete rules : can not marshal")
 	}
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, filteredStreamRules, bytes.NewBuffer(jsonStr))
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, addOrDeleteRulesURL, bytes.NewBuffer(jsonStr))
 	if err != nil {
 		return nil, fmt.Errorf("add or delete rules new request with ctx: %w", err)
 	}
@@ -115,6 +72,45 @@ func addOrDeleteRules(ctx context.Context, c *client, body *AddOrDeleteJSONBody,
 	return &addOrDelete, nil
 }
 
+func retrieveStreamRules(ctx context.Context, c *client, opt ...*RetrieveStreamRulesOption) (*RetrieveStreamRulesResponse, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, retrieveStreamRulesURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("retrieve stream rules new request with ctx: %w", err)
+	}
+	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
+
+	var topt RetrieveStreamRulesOption
+	switch len(opt) {
+	case 0:
+		// do nothing
+	case 1:
+		topt = *opt[0]
+	default:
+		return nil, errors.New("retrieve stream rules: only one option is allowed")
+	}
+	topt.addQuery(req)
+
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("retrieve stream rules: %w", err)
+	}
+	defer resp.Body.Close()
+
+	var tweet RetrieveStreamRulesResponse
+	if err := json.NewDecoder(resp.Body).Decode(&tweet); err != nil {
+		return nil, fmt.Errorf("retrieve stream rules decode: %w", err)
+	}
+	if resp.StatusCode != http.StatusOK {
+		return &tweet, &HTTPError{
+			APIName: "retrieve stream rules",
+			Status:  resp.Status,
+			URL:     req.URL.String(),
+		}
+	}
+
+	return &tweet, nil
+}
+
 func (s *ConnectToStream) Stop() {
 	close(s.done)
 	s.wg.Wait()
@@ -152,7 +148,7 @@ func (s *ConnectToStream) retry(req *http.Request) {
 }
 
 func connectToStream(ctx context.Context, c *client, ch chan<- ConnectToStreamResponse, errCh chan<- error, opt ...*ConnectToStreamOption) *ConnectToStream {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, filteredStream, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, connectToStreamURL, nil)
 	if err != nil {
 		errCh <- fmt.Errorf("connect to stream new request with ctx: %w", err)
 	}
diff --git a/follows.go b/follow.go
similarity index 50%
rename from follows.go
rename to follow.go
index 84a367e..3ba9118 100644
--- a/follows.go
+++ b/follow.go
@@ -8,45 +8,44 @@ import (
 	"net/http"
 )
 
-func lookUpFollowing(ctx context.Context, c *client, id string, opt ...*FollowOption) (*FollowingResponse, error) {
-	// check id
-	if id == "" {
-		return nil, errors.New("following by id: id parameter is required")
+func followers(ctx context.Context, c *client, userID string, opt ...*FollowOption) (*FollowersResponse, error) {
+	if userID == "" {
+		return nil, errors.New("followers: userID parameter is required")
 	}
-	following := followingLookUp + "/" + id + "/following"
+	ep := fmt.Sprintf(followersURL, userID)
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, following, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep, nil)
 	if err != nil {
-		return nil, fmt.Errorf("following by id new request with ctx: %w", err)
+		return nil, fmt.Errorf("followers new request with ctx: %w", err)
 	}
 
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
 
-	var topt FollowOption
+	var fopt FollowOption
 	switch len(opt) {
 	case 0:
 		// do nothing
 	case 1:
-		topt = *opt[0]
+		fopt = *opt[0]
 	default:
-		return nil, errors.New("following: only one option is allowed")
+		return nil, errors.New("followers: only one option is allowed")
 	}
-	topt.addQuery(req)
+	fopt.addQuery(req)
 
 	resp, err := c.client.Do(req)
 	if err != nil {
-		return nil, fmt.Errorf("following by id response: %w", err)
+		return nil, fmt.Errorf("followers response: %w", err)
 	}
 
 	defer resp.Body.Close()
 
-	var f FollowingResponse
+	var f FollowersResponse
 	if err := json.NewDecoder(resp.Body).Decode(&f); err != nil {
-		return nil, fmt.Errorf("following by id decode: %w", err)
+		return nil, fmt.Errorf("followers by id decode: %w", err)
 	}
 	if resp.StatusCode != http.StatusOK {
 		return &f, &HTTPError{
-			APIName: "following by id",
+			APIName: "followers",
 			Status:  resp.Status,
 			URL:     req.URL.String(),
 		}
@@ -55,45 +54,44 @@ func lookUpFollowing(ctx context.Context, c *client, id string, opt ...*FollowOp
 	return &f, nil
 }
 
-func lookUpFollowers(ctx context.Context, c *client, id string, opt ...*FollowOption) (*FollowersResponse, error) {
-	// check id
-	if id == "" {
-		return nil, errors.New("followers by id: id parameter is required")
+func following(ctx context.Context, c *client, userID string, opt ...*FollowOption) (*FollowingResponse, error) {
+	if userID == "" {
+		return nil, errors.New("following: userID parameter is required")
 	}
-	followers := followersLookUp + "/" + id + "/followers"
+	ep := fmt.Sprintf(followingURL, userID)
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, followers, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep, nil)
 	if err != nil {
-		return nil, fmt.Errorf("followers by id new request with ctx: %w", err)
+		return nil, fmt.Errorf("following new request with ctx: %w", err)
 	}
 
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
 
-	var topt FollowOption
+	var fopt FollowOption
 	switch len(opt) {
 	case 0:
 		// do nothing
 	case 1:
-		topt = *opt[0]
+		fopt = *opt[0]
 	default:
-		return nil, errors.New("followers: only one option is allowed")
+		return nil, errors.New("following: only one option is allowed")
 	}
-	topt.addQuery(req)
+	fopt.addQuery(req)
 
 	resp, err := c.client.Do(req)
 	if err != nil {
-		return nil, fmt.Errorf("followers by id response: %w", err)
+		return nil, fmt.Errorf("following response: %w", err)
 	}
 
 	defer resp.Body.Close()
 
-	var f FollowersResponse
+	var f FollowingResponse
 	if err := json.NewDecoder(resp.Body).Decode(&f); err != nil {
-		return nil, fmt.Errorf("followers by id decode: %w", err)
+		return nil, fmt.Errorf("following: %w", err)
 	}
 	if resp.StatusCode != http.StatusOK {
 		return &f, &HTTPError{
-			APIName: "followers by id",
+			APIName: "following",
 			Status:  resp.Status,
 			URL:     req.URL.String(),
 		}
diff --git a/likes_lookup.go b/likes_lookup.go
index cb76aeb..efa7132 100644
--- a/likes_lookup.go
+++ b/likes_lookup.go
@@ -8,47 +8,46 @@ import (
 	"net/http"
 )
 
-func lookUpUsersWhoLiked(ctx context.Context, c *client, tweetID string, opt ...*LookUpUsersWhoLikedOpts) (*LookUpUsersWhoLikedResponse, error) {
-	// check id
-	if len(tweetID) == 0 {
-		return nil, errors.New("look up users who liked: tweetID parameter is required")
+func usersLikingTweet(ctx context.Context, c *client, tweetID string, opt ...*UsersLikingTweetOption) (*UsersLikingTweetResponse, error) {
+	if tweetID == "" {
+		return nil, errors.New("users liking tweet: tweet id parameter is required")
 	}
-	likesLookUpUsersURL := likesLookUpUsers + "/" + tweetID + "/liking_users"
+	ep := fmt.Sprintf(usersLikingTweetURL, tweetID)
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, likesLookUpUsersURL, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep, nil)
 	if err != nil {
-		return nil, fmt.Errorf("look up users who liked: new request with ctx: %w", err)
+		return nil, fmt.Errorf("users liking tweet new request with ctx: %w", err)
 	}
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
 
-	var topt LookUpUsersWhoLikedOpts
+	var uopt UsersLikingTweetOption
 	switch len(opt) {
 	case 0:
 		// do nothing
 	case 1:
-		topt = *opt[0]
+		uopt = *opt[0]
 	default:
-		return nil, errors.New("look up users who liked: only one option is allowed")
+		return nil, errors.New("users liking tweet: only one option is allowed")
 	}
-	topt.addQuery(req)
+	uopt.addQuery(req)
 
 	resp, err := c.client.Do(req)
 	if err != nil {
-		return nil, fmt.Errorf("look up users who liked response: %w", err)
+		return nil, fmt.Errorf("users liking tweet: %w", err)
 	}
 	defer resp.Body.Close()
 
-	var usersWhoLiked LookUpUsersWhoLikedResponse
-	if err := json.NewDecoder(resp.Body).Decode(&usersWhoLiked); err != nil {
-		return nil, fmt.Errorf("look up users who liked decode: %w", err)
+	var ultr UsersLikingTweetResponse
+	if err := json.NewDecoder(resp.Body).Decode(&ultr); err != nil {
+		return nil, fmt.Errorf("users liking tweet: %w", err)
 	}
 	if resp.StatusCode != http.StatusOK {
-		return &usersWhoLiked, &HTTPError{
-			APIName: "look up users who liked",
+		return &ultr, &HTTPError{
+			APIName: "users liking tweet",
 			Status:  resp.Status,
 			URL:     req.URL.String(),
 		}
 	}
 
-	return &usersWhoLiked, nil
+	return &ultr, nil
 }
diff --git a/list.go b/list.go
index fd48aaa..e08ce02 100644
--- a/list.go
+++ b/list.go
@@ -33,7 +33,7 @@ type ListMeta struct {
 	NextToken     string `json:"next_token,omitempty"`
 }
 
-type OwnedListsLookUpByIDResponse struct {
+type AllListsOwnedResponse struct {
 	Lists    []*List             `json:"data"`
 	Includes *ListIncludes       `json:"includes,omitempty"`
 	Errors   []*APIResponseError `json:"errors,omitempty"`
@@ -43,7 +43,7 @@ type OwnedListsLookUpByIDResponse struct {
 	Type     string              `json:"type,omitempty"`
 }
 
-type ListLookUpByIDResponse struct {
+type ListResponse struct {
 	List     *List               `json:"data"`
 	Includes *ListIncludes       `json:"includes,omitempty"`
 	Errors   []*APIResponseError `json:"errors,omitempty"`
@@ -52,7 +52,7 @@ type ListLookUpByIDResponse struct {
 	Type     string              `json:"type,omitempty"`
 }
 
-type ListsTweetsLookUpByIDResponse struct {
+type ListTweetsResponse struct {
 	Tweets   []*Tweet            `json:"data"`
 	Includes *ListIncludes       `json:"includes,omitempty"`
 	Errors   []*APIResponseError `json:"errors,omitempty"`
@@ -62,7 +62,7 @@ type ListsTweetsLookUpByIDResponse struct {
 	Type     string              `json:"type,omitempty"`
 }
 
-type ListFollowersLookUpByIDResponse struct {
+type ListFollowersResponse struct {
 	Users    []*User             `json:"data"`
 	Includes *ListIncludes       `json:"includes,omitempty"`
 	Errors   []*APIResponseError `json:"errors,omitempty"`
@@ -72,7 +72,7 @@ type ListFollowersLookUpByIDResponse struct {
 	Type     string              `json:"type,omitempty"`
 }
 
-type ListsUserFollowingLookUpByIDResponse struct {
+type AllListsUserFollowsResponse struct {
 	Lists    []*List             `json:"data"`
 	Includes *ListIncludes       `json:"includes,omitempty"`
 	Errors   []*APIResponseError `json:"errors,omitempty"`
diff --git a/list_follows.go b/list_follows.go
index 7c0329e..f2a3298 100644
--- a/list_follows.go
+++ b/list_follows.go
@@ -8,92 +8,91 @@ import (
 	"net/http"
 )
 
-func lookUpListFollowersByID(ctx context.Context, c *client, id string, opt ...*ListLookUpOption) (*ListFollowersLookUpByIDResponse, error) {
-	if id == "" {
-		return nil, errors.New("list followers lookup by id: id parameter is required")
+func lookUpListFollowers(ctx context.Context, c *client, listID string, opt ...*ListFollowersOption) (*ListFollowersResponse, error) {
+	if listID == "" {
+		return nil, errors.New("look up list followers: listID parameter is required")
 	}
-	lookUpListFollowersByID := listFollowersLookUp + "/" + id + "/followers"
+	ep := fmt.Sprintf(lookUpListFollowersURL, listID)
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, lookUpListFollowersByID, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep, nil)
 	if err != nil {
-		return nil, fmt.Errorf("list followers lookup by id new request with ctx: %w", err)
+		return nil, fmt.Errorf("look up list followers new request with ctx: %w", err)
 	}
 
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
 
-	var topt ListLookUpOption
+	var lopt ListFollowersOption
 	switch len(opt) {
 	case 0:
 		// do nothing
 	case 1:
-		topt = *opt[0]
+		lopt = *opt[0]
 	default:
-		return nil, errors.New("list followers lookup by id: only one option is allowed")
+		return nil, errors.New("look up list followers: only one option is allowed")
 	}
-	topt.addQuery(req)
+	lopt.addQuery(req)
 
 	resp, err := c.client.Do(req)
 	if err != nil {
-		return nil, fmt.Errorf("list followers lookup by id response: %w", err)
+		return nil, fmt.Errorf("look up list followers: %w", err)
 	}
-
 	defer resp.Body.Close()
 
-	var list ListFollowersLookUpByIDResponse
-	if err := json.NewDecoder(resp.Body).Decode(&list); err != nil {
-		return nil, fmt.Errorf("list followers lookup by id decode: %w", err)
+	var lfr ListFollowersResponse
+	if err := json.NewDecoder(resp.Body).Decode(&lfr); err != nil {
+		return nil, fmt.Errorf("look up list followers: %w", err)
 	}
 	if resp.StatusCode != http.StatusOK {
-		return &list, &HTTPError{
-			APIName: "list followers lookup by id",
+		return &lfr, &HTTPError{
+			APIName: "look up list followers",
 			Status:  resp.Status,
 			URL:     req.URL.String(),
 		}
 	}
 
-	return &list, nil
+	return &lfr, nil
 }
 
-func lookUpListsUserFollowingByID(ctx context.Context, c *client, id string, opt ...*ListLookUpOption) (*ListsUserFollowingLookUpByIDResponse, error) {
-	if id == "" {
-		return nil, errors.New("lists user following lookup by id: id parameter is required")
+func lookUpAllListsUserFollows(ctx context.Context, c *client, userID string, opt ...*ListFollowsOption) (*AllListsUserFollowsResponse, error) {
+	if userID == "" {
+		return nil, errors.New("look up all lists user follows: userID parameter is required")
 	}
-	listsUserFollowingLookUpByID := listsUserFollowingLookUp + "/" + id + "/followed_lists"
+	ep := fmt.Sprintf(lookUpAllListsUserFollowsURL, userID)
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, listsUserFollowingLookUpByID, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep, nil)
 	if err != nil {
-		return nil, fmt.Errorf("lists user following lookup new request with ctx: %w", err)
+		return nil, fmt.Errorf("look up all lists user follows new request with ctx: %w", err)
 	}
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
 
-	var topt ListLookUpOption
+	var lopt ListFollowsOption
 	switch len(opt) {
 	case 0:
 		// do nothing
 	case 1:
-		topt = *opt[0]
+		lopt = *opt[0]
 	default:
-		return nil, errors.New("lists user following lookup by id: only one option is allowed")
+		return nil, errors.New("look up all lists user follows: only one option is allowed")
 	}
-	topt.addQuery(req)
+	lopt.addQuery(req)
 
 	resp, err := c.client.Do(req)
 	if err != nil {
-		return nil, fmt.Errorf("lists user following lookup by id response: %w", err)
+		return nil, fmt.Errorf("look up all lists user follows: %w", err)
 	}
 	defer resp.Body.Close()
 
-	var list ListsUserFollowingLookUpByIDResponse
-	if err := json.NewDecoder(resp.Body).Decode(&list); err != nil {
-		return nil, fmt.Errorf("lists user following lookup by id decode: %w", err)
+	var alufr AllListsUserFollowsResponse
+	if err := json.NewDecoder(resp.Body).Decode(&alufr); err != nil {
+		return nil, fmt.Errorf("look up all lists user follows: %w", err)
 	}
 	if resp.StatusCode != http.StatusOK {
-		return &list, &HTTPError{
-			APIName: "lists user following lookup by id",
+		return &alufr, &HTTPError{
+			APIName: "look up all lists user follows",
 			Status:  resp.Status,
 			URL:     req.URL.String(),
 		}
 	}
 
-	return &list, nil
+	return &alufr, nil
 }
diff --git a/list_lookup.go b/list_lookup.go
index 35d6f0d..80bc10a 100644
--- a/list_lookup.go
+++ b/list_lookup.go
@@ -8,92 +8,92 @@ import (
 	"net/http"
 )
 
-func lookUpOwnedListsByID(ctx context.Context, c *client, id string, opt ...*ListLookUpOption) (*OwnedListsLookUpByIDResponse, error) {
-	if id == "" {
-		return nil, errors.New("owned lists lookup by id: id parameter is required")
+func lookUpList(ctx context.Context, c *client, listID string, opt ...*LookUpListOption) (*ListResponse, error) {
+	if listID == "" {
+		return nil, errors.New("look up list: listID parameter is required")
 	}
-	lookUpOwnedListsByID := ownedListLookUp + "/" + id + "/owned_lists"
+	ep := fmt.Sprintf(lookUpListURL, listID)
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, lookUpOwnedListsByID, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep, nil)
 	if err != nil {
-		return nil, fmt.Errorf("owned lists lookup by id new request with ctx: %w", err)
+		return nil, fmt.Errorf("look up list new request with ctx: %w", err)
 	}
-
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
 
-	var topt ListLookUpOption
+	var lopt LookUpListOption
 	switch len(opt) {
 	case 0:
 		// do nothing
 	case 1:
-		topt = *opt[0]
+		lopt = *opt[0]
 	default:
-		return nil, errors.New("owned lists lookup by id: only one option is allowed")
+		return nil, errors.New("look up list: only one option is allowed")
 	}
-	topt.addQuery(req)
+	lopt.addQuery(req)
 
 	resp, err := c.client.Do(req)
 	if err != nil {
-		return nil, fmt.Errorf("owned lists lookup by id response: %w", err)
+		return nil, fmt.Errorf("look up list response: %w", err)
 	}
-
 	defer resp.Body.Close()
 
-	var list OwnedListsLookUpByIDResponse
-	if err := json.NewDecoder(resp.Body).Decode(&list); err != nil {
-		return nil, fmt.Errorf("owned lists lookup by id decode: %w", err)
+	var lr ListResponse
+	if err := json.NewDecoder(resp.Body).Decode(&lr); err != nil {
+		return nil, fmt.Errorf("look up list decode: %w", err)
 	}
 	if resp.StatusCode != http.StatusOK {
-		return &list, &HTTPError{
-			APIName: "owned lists lookup by id",
+		return &lr, &HTTPError{
+			APIName: "look up list",
 			Status:  resp.Status,
 			URL:     req.URL.String(),
 		}
 	}
 
-	return &list, nil
+	return &lr, nil
 }
 
-func lookUpListByID(ctx context.Context, c *client, id string, opt ...*ListLookUpOption) (*ListLookUpByIDResponse, error) {
-	if id == "" {
-		return nil, errors.New("list lookup by id: id parameter is required")
+func lookUpAllListsOwned(ctx context.Context, c *client, userID string, opt ...*AllListsOwnedOption) (*AllListsOwnedResponse, error) {
+	if userID == "" {
+		return nil, errors.New("look up all lists owned: userID parameter is required")
 	}
-	listLookUpByID := listLookUp + "/" + id
+	ep := fmt.Sprintf(lookUpAllListsOwnedURL, userID)
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, listLookUpByID, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep, nil)
 	if err != nil {
-		return nil, fmt.Errorf("list lookup new request with ctx: %w", err)
+		return nil, fmt.Errorf("look up all lists owned new request with ctx: %w", err)
 	}
+
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
 
-	var topt ListLookUpOption
+	var aopt AllListsOwnedOption
 	switch len(opt) {
 	case 0:
 		// do nothing
 	case 1:
-		topt = *opt[0]
+		aopt = *opt[0]
 	default:
-		return nil, errors.New("list lookup by id: only one option is allowed")
+		return nil, errors.New("look up all lists owned: only one option is allowed")
 	}
-	topt.addQuery(req)
+	aopt.addQuery(req)
 
 	resp, err := c.client.Do(req)
 	if err != nil {
-		return nil, fmt.Errorf("list lookup by id response: %w", err)
+		return nil, fmt.Errorf("look up all lists owned response: %w", err)
 	}
+
 	defer resp.Body.Close()
 
-	var list ListLookUpByIDResponse
-	if err := json.NewDecoder(resp.Body).Decode(&list); err != nil {
-		return nil, fmt.Errorf("list lookup by id decode: %w", err)
+	var alor AllListsOwnedResponse
+	if err := json.NewDecoder(resp.Body).Decode(&alor); err != nil {
+		return nil, fmt.Errorf("look up all lists owned decode: %w", err)
 	}
 	if resp.StatusCode != http.StatusOK {
-		return &list, &HTTPError{
-			APIName: "list lookup by id",
+		return &alor, &HTTPError{
+			APIName: "look up all lists owned",
 			Status:  resp.Status,
 			URL:     req.URL.String(),
 		}
 	}
 
-	return &list, nil
+	return &alor, nil
 }
diff --git a/list_members.go b/list_members.go
index 80a4a7e..a0dbccc 100644
--- a/list_members.go
+++ b/list_members.go
@@ -21,16 +21,16 @@ func listMembers(ctx context.Context, c *client, listid string, opt ...*ListMemb
 
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
 
-	var topt ListMembersOption
+	var lopt ListMembersOption
 	switch len(opt) {
 	case 0:
 		// do nothing
 	case 1:
-		topt = *opt[0]
+		lopt = *opt[0]
 	default:
 		return nil, errors.New("look up list members: only one option is allowed")
 	}
-	topt.addQuery(req)
+	lopt.addQuery(req)
 
 	resp, err := c.client.Do(req)
 	if err != nil {
diff --git a/list_option.go b/list_option.go
index 0ab328d..180d2f0 100644
--- a/list_option.go
+++ b/list_option.go
@@ -6,22 +6,100 @@ import (
 	"strings"
 )
 
-type ListLookUpOption struct {
+type LookUpListOption struct {
+	Expansions []Expansion
+	ListFields []ListField
+	UserFields []UserField
+}
+
+func (l LookUpListOption) addQuery(req *http.Request) {
+	q := req.URL.Query()
+	if len(l.Expansions) > 0 {
+		q.Add("expansions", strings.Join(expansionsToString(l.Expansions), ","))
+	}
+	if len(l.ListFields) > 0 {
+		q.Add("list.fields", strings.Join(listFieldsToString(l.ListFields), "."))
+	}
+	if len(l.UserFields) > 0 {
+		q.Add("user.fields", strings.Join(userFieldsToString(l.UserFields), ","))
+	}
+	if len(q) > 0 {
+		req.URL.RawQuery = q.Encode()
+	}
+}
+
+type AllListsOwnedOption struct {
 	Expansions      []Expansion
 	ListFields      []ListField
 	MaxResults      int
 	PaginationToken string
+	UserFields      []UserField
+}
+
+func (a AllListsOwnedOption) addQuery(req *http.Request) {
+	q := req.URL.Query()
+	if len(a.Expansions) > 0 {
+		q.Add("expansions", strings.Join(expansionsToString(a.Expansions), ","))
+	}
+	if len(a.ListFields) > 0 {
+		q.Add("list.fields", strings.Join(listFieldsToString(a.ListFields), "."))
+	}
+	if a.MaxResults > 0 {
+		q.Add("max_results", strconv.Itoa(a.MaxResults))
+	}
+	if a.PaginationToken != "" {
+		q.Add("pagination_token", a.PaginationToken)
+	}
+	if len(a.UserFields) > 0 {
+		q.Add("user.fields", strings.Join(userFieldsToString(a.UserFields), ","))
+	}
+	if len(q) > 0 {
+		req.URL.RawQuery = q.Encode()
+	}
+}
+
+type ListTweetsOption struct {
+	Expansions      []Expansion
+	MaxResults      int
+	PaginationToken string
 	TweetFields     []TweetField
 	UserFields      []UserField
 }
 
-func (l *ListLookUpOption) addQuery(req *http.Request) {
+func (l ListTweetsOption) addQuery(req *http.Request) {
 	q := req.URL.Query()
 	if len(l.Expansions) > 0 {
 		q.Add("expansions", strings.Join(expansionsToString(l.Expansions), ","))
 	}
-	if len(l.ListFields) > 0 {
-		q.Add("list.fields", strings.Join(listFieldsToString(l.ListFields), "."))
+	if l.MaxResults > 0 {
+		q.Add("max_results", strconv.Itoa(l.MaxResults))
+	}
+	if l.PaginationToken != "" {
+		q.Add("pagination_token", l.PaginationToken)
+	}
+	if len(l.TweetFields) > 0 {
+		q.Add("tweet.fields", strings.Join(tweetFieldsToString(l.TweetFields), "."))
+	}
+	if len(l.UserFields) > 0 {
+		q.Add("user.fields", strings.Join(userFieldsToString(l.UserFields), ","))
+	}
+	if len(q) > 0 {
+		req.URL.RawQuery = q.Encode()
+	}
+}
+
+type ListMembersOption struct {
+	Expansions      []Expansion
+	MaxResults      int
+	PaginationToken string
+	TweetFields     []TweetField
+	UserFields      []UserField
+}
+
+func (l ListMembersOption) addQuery(req *http.Request) {
+	q := req.URL.Query()
+	if len(l.Expansions) > 0 {
+		q.Add("expansions", strings.Join(expansionsToString(l.Expansions), ","))
 	}
 	if l.MaxResults > 0 {
 		q.Add("max_results", strconv.Itoa(l.MaxResults))
@@ -40,15 +118,37 @@ func (l *ListLookUpOption) addQuery(req *http.Request) {
 	}
 }
 
-func listFieldsToString(lfs []ListField) []string {
-	slice := make([]string, len(lfs))
-	for i, lf := range lfs {
-		slice[i] = string(lf)
+type ListFollowsOption struct {
+	Expansions      []Expansion
+	ListFields      []ListField
+	MaxResults      int
+	PaginationToken string
+	UserFields      []UserField
+}
+
+func (l ListFollowsOption) addQuery(req *http.Request) {
+	q := req.URL.Query()
+	if len(l.Expansions) > 0 {
+		q.Add("expansions", strings.Join(expansionsToString(l.Expansions), ","))
+	}
+	if len(l.ListFields) > 0 {
+		q.Add("list.fields", strings.Join(listFieldsToString(l.ListFields), "."))
+	}
+	if l.MaxResults > 0 {
+		q.Add("max_results", strconv.Itoa(l.MaxResults))
+	}
+	if l.PaginationToken != "" {
+		q.Add("pagination_token", l.PaginationToken)
+	}
+	if len(l.UserFields) > 0 {
+		q.Add("user.fields", strings.Join(userFieldsToString(l.UserFields), ","))
+	}
+	if len(q) > 0 {
+		req.URL.RawQuery = q.Encode()
 	}
-	return slice
 }
 
-type ListMembersOption struct {
+type ListFollowersOption struct {
 	Expansions      []Expansion
 	MaxResults      int
 	PaginationToken string
@@ -56,7 +156,7 @@ type ListMembersOption struct {
 	UserFields      []UserField
 }
 
-func (l *ListMembersOption) addQuery(req *http.Request) {
+func (l ListFollowersOption) addQuery(req *http.Request) {
 	q := req.URL.Query()
 	if len(l.Expansions) > 0 {
 		q.Add("expansions", strings.Join(expansionsToString(l.Expansions), ","))
@@ -77,3 +177,11 @@ func (l *ListMembersOption) addQuery(req *http.Request) {
 		req.URL.RawQuery = q.Encode()
 	}
 }
+
+func listFieldsToString(lfs []ListField) []string {
+	slice := make([]string, len(lfs))
+	for i, lf := range lfs {
+		slice[i] = string(lf)
+	}
+	return slice
+}
diff --git a/list_tweets_lookup.go b/list_tweets_lookup.go
index c1c19a2..fd0fef3 100644
--- a/list_tweets_lookup.go
+++ b/list_tweets_lookup.go
@@ -8,48 +8,47 @@ import (
 	"net/http"
 )
 
-func lookUpListsTweetsByID(ctx context.Context, c *client, id string, opt ...*ListLookUpOption) (*ListsTweetsLookUpByIDResponse, error) {
-	if id == "" {
-		return nil, errors.New("lists tweets lookup by id: id parameter is required")
+func lookUpListTweets(ctx context.Context, c *client, listID string, opt ...*ListTweetsOption) (*ListTweetsResponse, error) {
+	if listID == "" {
+		return nil, errors.New("look up list tweets: listID parameter is required")
 	}
-	lookUpListsTweetsByID := listsTweetsLookUp + "/" + id + "/tweets"
+	ep := fmt.Sprintf(lookUpListTweetsURL, listID)
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, lookUpListsTweetsByID, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep, nil)
 	if err != nil {
-		return nil, fmt.Errorf("lists tweets lookup by id new request with ctx: %w", err)
+		return nil, fmt.Errorf("look up list tweets new request with ctx: %w", err)
 	}
 
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
 
-	var topt ListLookUpOption
+	var lopt ListTweetsOption
 	switch len(opt) {
 	case 0:
 		// do nothing
 	case 1:
-		topt = *opt[0]
+		lopt = *opt[0]
 	default:
-		return nil, errors.New("lists tweets lookup by id: only one option is allowed")
+		return nil, errors.New("look up list tweets: only one option is allowed")
 	}
-	topt.addQuery(req)
+	lopt.addQuery(req)
 
 	resp, err := c.client.Do(req)
 	if err != nil {
-		return nil, fmt.Errorf("lists tweets lookup by id response: %w", err)
+		return nil, fmt.Errorf("look up list tweets: %w", err)
 	}
-
 	defer resp.Body.Close()
 
-	var list ListsTweetsLookUpByIDResponse
-	if err := json.NewDecoder(resp.Body).Decode(&list); err != nil {
-		return nil, fmt.Errorf("lists tweets lookup by id decode: %w", err)
+	var ltr ListTweetsResponse
+	if err := json.NewDecoder(resp.Body).Decode(&ltr); err != nil {
+		return nil, fmt.Errorf("look up list tweets: %w", err)
 	}
 	if resp.StatusCode != http.StatusOK {
-		return &list, &HTTPError{
-			APIName: "lists tweets lookup by id",
+		return &ltr, &HTTPError{
+			APIName: "look up list tweets",
 			Status:  resp.Status,
 			URL:     req.URL.String(),
 		}
 	}
 
-	return &list, nil
+	return &ltr, nil
 }
diff --git a/retweets.go b/retweet.go
similarity index 68%
rename from retweets.go
rename to retweet.go
index 24a31c6..fd674c2 100644
--- a/retweets.go
+++ b/retweet.go
@@ -8,19 +8,19 @@ import (
 	"net/http"
 )
 
-func retweetsLookup(ctx context.Context, c *client, id string, opt ...*RetweetsLookupOpts) (*RetweetsLookupResponse, error) {
-	if id == "" {
-		return nil, errors.New("retweets lookup by id: id parameter is required")
+func retweetsLookup(ctx context.Context, c *client, tweetID string, opt ...*RetweetsLookupOption) (*RetweetsResponse, error) {
+	if tweetID == "" {
+		return nil, errors.New("retweets lookup: tweet id parameter is required")
 	}
-	retweetsLookupPath := retweet + "/" + id + "/retweeted_by"
+	ep := fmt.Sprintf(retweetsLookupURL, tweetID)
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, retweetsLookupPath, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep, nil)
 	if err != nil {
 		return nil, fmt.Errorf("retweets lookup new request with ctx: %w", err)
 	}
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
 
-	var ropt RetweetsLookupOpts
+	var ropt RetweetsLookupOption
 	switch len(opt) {
 	case 0:
 		// do nothing
@@ -37,7 +37,7 @@ func retweetsLookup(ctx context.Context, c *client, id string, opt ...*RetweetsL
 	}
 	defer resp.Body.Close()
 
-	var retweetsLookup RetweetsLookupResponse
+	var retweetsLookup RetweetsResponse
 	if err := json.NewDecoder(resp.Body).Decode(&retweetsLookup); err != nil {
 		return nil, fmt.Errorf("retweets lookup decode: %w", err)
 	}
diff --git a/search_spaces.go b/search_spaces.go
index 8adcc11..14ea1f0 100644
--- a/search_spaces.go
+++ b/search_spaces.go
@@ -8,18 +8,15 @@ import (
 	"net/http"
 )
 
-func searchSpaces(ctx context.Context, c *client, query string, opt ...*SearchSpacesOption) (*SearchSpacesResponse, error) {
-	switch {
-	case len(query) == 0:
-		return nil, errors.New("search spaces: query is empty")
-	default:
+func searchSpaces(ctx context.Context, c *client, searchTerm string, opt ...*SearchSpacesOption) (*SearchSpacesResponse, error) {
+	if searchTerm == "" {
+		return nil, errors.New("search spaces: searchTerm parameter is required")
 	}
+	ep := fmt.Sprintf(searchSpacesURL, searchTerm)
 
-	searchSpaces := spacesSearch + "?query=" + query
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, searchSpaces, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep, nil)
 	if err != nil {
-		return nil, fmt.Errorf("search spaces: %w", err)
+		return nil, fmt.Errorf("search spaces new request with ctx: %w", err)
 	}
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
 
diff --git a/search_tweet.go b/search_tweet.go
new file mode 100644
index 0000000..0105834
--- /dev/null
+++ b/search_tweet.go
@@ -0,0 +1,57 @@
+package gotwtr
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+)
+
+func searchRecentTweets(ctx context.Context, c *client, tweet string, opt ...*SearchTweetsOption) (*SearchTweetsResponse, error) {
+	switch {
+	case tweet == "":
+		return nil, errors.New("search recent tweets: tweet parameter is required")
+	case len(tweet) > searchTweetMaxQueryLength:
+		return nil, errors.New("search recent tweets: tweet parameter must be less than or equal to 512 characters")
+	}
+
+	ep := fmt.Sprintf(searchRecentTweetsURL, tweet)
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep, nil)
+	if err != nil {
+		return nil, fmt.Errorf("search recent tweets new request with ctx: %w", err)
+	}
+	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
+
+	var sopt SearchTweetsOption
+	switch len(opt) {
+	case 0:
+		// do nothing
+	case 1:
+		sopt = *opt[0]
+	default:
+		return nil, errors.New("search recent tweets: only one option is allowed")
+	}
+	sopt.addQuery(req)
+
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("search recent tweets: %w", err)
+	}
+	defer resp.Body.Close()
+
+	var str SearchTweetsResponse
+	if err := json.NewDecoder(resp.Body).Decode(&str); err != nil {
+		return nil, fmt.Errorf("search recent tweets: %w", err)
+	}
+	if resp.StatusCode != http.StatusOK {
+		return &str, &HTTPError{
+			APIName: "search recent tweets",
+			Status:  resp.Status,
+			URL:     req.URL.String(),
+		}
+	}
+
+	return &str, nil
+}
diff --git a/search_tweets.go b/search_tweets.go
deleted file mode 100644
index 9c44675..0000000
--- a/search_tweets.go
+++ /dev/null
@@ -1,58 +0,0 @@
-package gotwtr
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"net/http"
-)
-
-func searchRecentTweets(ctx context.Context, c *client, query string, opt ...*TweetSearchOption) (*TweetSearchResponse, error) {
-	switch {
-	case len(query) == 0:
-		return nil, errors.New("tweets search recent: query is required")
-	case len(query) > tweetSearchMaxQueryLength:
-		return nil, errors.New("tweets search recent: query is too long")
-	default:
-	}
-
-	tweetRecent := tweetRecentSearch + "?query=" + query
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, tweetRecent, nil)
-	if err != nil {
-		return nil, fmt.Errorf("tweets search recent: %w", err)
-	}
-	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
-
-	var topt TweetSearchOption
-	switch len(opt) {
-	case 0:
-		// do nothing
-	case 1:
-		topt = *opt[0]
-	default:
-		return nil, errors.New("tweets search recent: only one option is allowed")
-	}
-	topt.addQuery(req)
-
-	resp, err := c.client.Do(req)
-	if err != nil {
-		return nil, fmt.Errorf("tweets search recent: %w", err)
-	}
-	defer resp.Body.Close()
-
-	var tsr TweetSearchResponse
-	if err := json.NewDecoder(resp.Body).Decode(&tsr); err != nil {
-		return nil, fmt.Errorf("tweets search recent: %w", err)
-	}
-	if resp.StatusCode != http.StatusOK {
-		return nil, &HTTPError{
-			APIName: "tweets search recent",
-			Status:  resp.Status,
-			URL:     req.URL.String(),
-		}
-	}
-
-	return &tsr, nil
-}
diff --git a/space.go b/space.go
index 705d7a0..99f5cee 100644
--- a/space.go
+++ b/space.go
@@ -72,7 +72,7 @@ type SpaceIncludes struct {
 	Users  []*User
 }
 
-type SpaceLookUpByIDResponse struct {
+type SpaceResponse struct {
 	Space    *Space              `json:"data,omitempty"`
 	Includes *SpaceIncludes      `json:"includes,omitempty"`
 	Errors   []*APIResponseError `json:"errors,omitempty"`
@@ -81,7 +81,7 @@ type SpaceLookUpByIDResponse struct {
 	Type     string              `json:"type,omitempty"`
 }
 
-type SpaceLookUpResponse struct {
+type SpacesResponse struct {
 	Spaces   []*Space            `json:"data,omitempty"`
 	Includes *SpaceIncludes      `json:"includes,omitempty"`
 	Errors   []*APIResponseError `json:"errors,omitempty"`
@@ -90,7 +90,7 @@ type SpaceLookUpResponse struct {
 	Type     string              `json:"type,omitempty"`
 }
 
-type DiscoverSpacesByUserIDsResponse struct {
+type DiscoverSpacesResponse struct {
 	Spaces   []*Space            `json:"data"`
 	Includes *SpaceIncludes      `json:"includes,omitempty"`
 	Errors   []*APIResponseError `json:"errors,omitempty"`
@@ -101,7 +101,7 @@ type DiscoverSpacesMeta struct {
 	ResultCount int `json:"result_count"`
 }
 
-type LookUpUsersWhoPurchasedSpaceTicketResponse struct {
+type UsersPurchasedSpaceTicketResponse struct {
 	Users    []*User                                     `json:"data"`
 	Includes *LookUpUsersWhoPurchasedSpaceTicketIncludes `json:"includes,omitempty"`
 	Errors   []*APIResponseError                         `json:"errors,omitempty"`
diff --git a/space_lookup.go b/space_lookup.go
index 39e1150..cc3ffa5 100644
--- a/space_lookup.go
+++ b/space_lookup.go
@@ -8,156 +8,153 @@ import (
 	"net/http"
 )
 
-func lookUpSpaces(ctx context.Context, c *client, ids []string, opt ...*SpaceLookUpOption) (*SpaceLookUpResponse, error) {
-	// check ids
-	switch {
-	case len(ids) == 0:
-		return nil, errors.New("space lookup: ids parameter is required")
-	case len(ids) > spaceLookUpMaxIDs:
-		return nil, errors.New("space lookup: ids parameter must be less than or equal to 100")
-	default:
-	}
-
-	spaceLookUp := spaceLookUp + "?ids="
-	// join ids to url
-	for i, id := range ids {
-		if i+1 < len(ids) {
-			spaceLookUp += fmt.Sprintf("%s,", id)
-		} else {
-			spaceLookUp += id
-		}
+func lookUpSpace(ctx context.Context, c *client, spaceID string, opt ...*SpaceOption) (*SpaceResponse, error) {
+	if spaceID == "" {
+		return nil, errors.New("look up space: spaceID parameter is required")
 	}
+	ep := fmt.Sprintf(spaceURL, spaceID)
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, spaceLookUp, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep, nil)
 	if err != nil {
-		return nil, fmt.Errorf("space lookup new request with ctx: %w", err)
+		return nil, fmt.Errorf("look up space new request with ctx: %w", err)
 	}
+
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
 
-	var sopt SpaceLookUpOption
+	var sopt SpaceOption
 	switch len(opt) {
 	case 0:
 		// do nothing
 	case 1:
 		sopt = *opt[0]
 	default:
-		return nil, errors.New("space lookup: only one option is allowed")
+		return nil, errors.New("look up space: only one option is allowed")
 	}
 	sopt.addQuery(req)
 
 	resp, err := c.client.Do(req)
 	if err != nil {
-		return nil, fmt.Errorf("space lookup response: %w", err)
+		return nil, fmt.Errorf("look up space response: %w", err)
 	}
-	defer resp.Body.Close()
 
-	var slr SpaceLookUpResponse
+	defer resp.Body.Close()
 
-	if err := json.NewDecoder(resp.Body).Decode(&slr); err != nil {
+	var sr SpaceResponse
+	if err := json.NewDecoder(resp.Body).Decode(&sr); err != nil {
 		return nil, fmt.Errorf("space lookup: %w", err)
 	}
 
 	if resp.StatusCode != http.StatusOK {
-		return &slr, &HTTPError{
-			APIName: "space lookup",
+		return &sr, &HTTPError{
+			APIName: "space lookup by id",
 			Status:  resp.Status,
 			URL:     req.URL.String(),
 		}
 	}
 
-	return &slr, nil
+	return &sr, nil
 }
 
-func lookUpSpaceByID(ctx context.Context, c *client, id string, opt ...*SpaceLookUpOption) (*SpaceLookUpByIDResponse, error) {
-	if id == "" {
-		return nil, errors.New("space lookup by id: id parameter is required")
+func lookUpSpaces(ctx context.Context, c *client, spaceIDs []string, opt ...*SpaceOption) (*SpacesResponse, error) {
+	switch {
+	case len(spaceIDs) == 0:
+		return nil, errors.New("look up spaces: spaceIDs parameter is required")
+	case len(spaceIDs) > spaceLookUpMaxIDs:
+		return nil, fmt.Errorf("look up spaces: spaceIDs parameter must be less than %d", spaceLookUpMaxIDs)
+	default:
+	}
+	ep := spacesURL
+	for i, sid := range spaceIDs {
+		if i+1 < len(spaceIDs) {
+			ep += fmt.Sprintf("%s,", sid)
+		} else {
+			ep += sid
+		}
 	}
-	spaceLookUpByID := spaceLookUp + "/" + id
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, spaceLookUpByID, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep, nil)
 	if err != nil {
-		return nil, fmt.Errorf("space lookup by id: %w", err)
+		return nil, fmt.Errorf("look up spaces new request with ctx: %w", err)
 	}
-
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
 
-	var sopt SpaceLookUpOption
+	var sopt SpaceOption
 	switch len(opt) {
 	case 0:
 		// do nothing
 	case 1:
 		sopt = *opt[0]
 	default:
-		return nil, errors.New("space lookup by id: only one option is allowed")
+		return nil, errors.New("look up spaces: only one option is allowed")
 	}
 	sopt.addQuery(req)
 
 	resp, err := c.client.Do(req)
 	if err != nil {
-		return nil, fmt.Errorf("space lookup by id: %w", err)
+		return nil, fmt.Errorf("look up spaces response: %w", err)
 	}
-
 	defer resp.Body.Close()
 
-	var slr SpaceLookUpByIDResponse
-	if err := json.NewDecoder(resp.Body).Decode(&slr); err != nil {
-		return nil, fmt.Errorf("space lookup by id: %w", err)
+	var sr SpacesResponse
+
+	if err := json.NewDecoder(resp.Body).Decode(&sr); err != nil {
+		return nil, fmt.Errorf("look up spaces: %w", err)
 	}
 
 	if resp.StatusCode != http.StatusOK {
-		return &slr, &HTTPError{
-			APIName: "space lookup by id",
+		return &sr, &HTTPError{
+			APIName: "look up spaces",
 			Status:  resp.Status,
 			URL:     req.URL.String(),
 		}
 	}
 
-	return &slr, nil
+	return &sr, nil
 }
 
-func lookUpUsersWhoPurchasedSpaceTicket(ctx context.Context, c *client, id string, opt ...*LookUpUsersWhoPurchasedSpaceTicketOption) (*LookUpUsersWhoPurchasedSpaceTicketResponse, error) {
-	if id == "" {
-		return nil, errors.New("look up users who purchased space ticket: id parameter is required")
+func usersPurchasedSpaceTicket(ctx context.Context, c *client, spaceID string, opt ...*UsersPurchasedSpaceTicketOption) (*UsersPurchasedSpaceTicketResponse, error) {
+	if spaceID == "" {
+		return nil, errors.New("users purchased space ticket: spaceID parameter is required")
 	}
-	spaceLookUpUsers := spaceLookUpBuyers + "/" + id + "/buyers"
+	ep := fmt.Sprintf(usersPurchasedSpaceTicketURL, spaceID)
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, spaceLookUpUsers, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep, nil)
 	if err != nil {
-		return nil, fmt.Errorf("look up users who purchased space ticket: %w", err)
+		return nil, fmt.Errorf("users purchased space ticket new request with ctx: %w", err)
 	}
 
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
 
-	var sopt LookUpUsersWhoPurchasedSpaceTicketOption
+	var uopt UsersPurchasedSpaceTicketOption
 	switch len(opt) {
 	case 0:
 		// do nothing
 	case 1:
-		sopt = *opt[0]
+		uopt = *opt[0]
 	default:
-		return nil, errors.New("look up users who purchased space ticket: only one option is allowed")
+		return nil, errors.New("users purchased space ticket: only one option is allowed")
 	}
-	sopt.addQuery(req)
+	uopt.addQuery(req)
 
 	resp, err := c.client.Do(req)
 	if err != nil {
-		return nil, fmt.Errorf("look up users who purchased space ticket: %w", err)
+		return nil, fmt.Errorf("users purchased space ticket response: %w", err)
 	}
 
 	defer resp.Body.Close()
 
-	var str LookUpUsersWhoPurchasedSpaceTicketResponse
-	if err := json.NewDecoder(resp.Body).Decode(&str); err != nil {
-		return nil, fmt.Errorf("look up users who purchased space ticket: %w", err)
+	var upstr UsersPurchasedSpaceTicketResponse
+	if err := json.NewDecoder(resp.Body).Decode(&upstr); err != nil {
+		return nil, fmt.Errorf("users purchased space ticket: %w", err)
 	}
 
 	if resp.StatusCode != http.StatusOK {
-		return nil, &HTTPError{
-			APIName: "look up users who purchased space ticket",
+		return &upstr, &HTTPError{
+			APIName: "users purchased space ticket",
 			Status:  resp.Status,
 			URL:     req.URL.String(),
 		}
 	}
 
-	return &str, nil
+	return &upstr, nil
 }
diff --git a/space_option.go b/space_option.go
index ae56dcf..77ebe37 100644
--- a/space_option.go
+++ b/space_option.go
@@ -56,14 +56,14 @@ func stateOptionToString(sopt []StateOption) []string {
 	return slice
 }
 
-type SpaceLookUpOption struct {
+type SpaceOption struct {
 	Expansions  []Expansion
 	SpaceFields []SpaceField
 	TopicFields []TopicField
 	UserFields  []UserField
 }
 
-func (s *SpaceLookUpOption) addQuery(req *http.Request) {
+func (s *SpaceOption) addQuery(req *http.Request) {
 	q := req.URL.Query()
 	if len(s.Expansions) > 0 {
 		q.Add("expansions", strings.Join(expansionsToString(s.Expansions), ","))
@@ -89,26 +89,26 @@ type DiscoverSpacesOption struct {
 	UserFields  []UserField
 }
 
-func (s *DiscoverSpacesOption) addQuery(req *http.Request) {
+func (d *DiscoverSpacesOption) addQuery(req *http.Request) {
 	q := req.URL.Query()
-	if len(s.Expansions) > 0 {
-		q.Add("expansions", strings.Join(expansionsToString(s.Expansions), ","))
+	if len(d.Expansions) > 0 {
+		q.Add("expansions", strings.Join(expansionsToString(d.Expansions), ","))
 	}
-	if len(s.SpaceFields) > 0 {
-		q.Add("space.fields", strings.Join(spaceFieldsToString(s.SpaceFields), ","))
+	if len(d.SpaceFields) > 0 {
+		q.Add("space.fields", strings.Join(spaceFieldsToString(d.SpaceFields), ","))
 	}
-	if len(s.TopicFields) > 0 {
-		q.Add("topic.fields", strings.Join(topicFieldsToString(s.TopicFields), ","))
+	if len(d.TopicFields) > 0 {
+		q.Add("topic.fields", strings.Join(topicFieldsToString(d.TopicFields), ","))
 	}
-	if len(s.UserFields) > 0 {
-		q.Add("user.fields", strings.Join(userFieldsToString(s.UserFields), ","))
+	if len(d.UserFields) > 0 {
+		q.Add("user.fields", strings.Join(userFieldsToString(d.UserFields), ","))
 	}
 	if len(q) > 0 {
 		req.URL.RawQuery = q.Encode()
 	}
 }
 
-type LookUpUsersWhoPurchasedSpaceTicketOption struct {
+type UsersPurchasedSpaceTicketOption struct {
 	Expansions  []Expansion
 	MediaFields []MediaField
 	PlaceFields []PlaceField
@@ -117,25 +117,25 @@ type LookUpUsersWhoPurchasedSpaceTicketOption struct {
 	UserFields  []UserField
 }
 
-func (o *LookUpUsersWhoPurchasedSpaceTicketOption) addQuery(req *http.Request) {
+func (u *UsersPurchasedSpaceTicketOption) addQuery(req *http.Request) {
 	q := req.URL.Query()
-	if len(o.Expansions) > 0 {
-		q.Add("expansions", strings.Join(expansionsToString(o.Expansions), ","))
+	if len(u.Expansions) > 0 {
+		q.Add("expansions", strings.Join(expansionsToString(u.Expansions), ","))
 	}
-	if len(o.MediaFields) > 0 {
-		q.Add("media.fields", strings.Join(mediaFieldsToString(o.MediaFields), ","))
+	if len(u.MediaFields) > 0 {
+		q.Add("media.fields", strings.Join(mediaFieldsToString(u.MediaFields), ","))
 	}
-	if len(o.PlaceFields) > 0 {
-		q.Add("place.fields", strings.Join(placeFieldsToString(o.PlaceFields), ","))
+	if len(u.PlaceFields) > 0 {
+		q.Add("place.fields", strings.Join(placeFieldsToString(u.PlaceFields), ","))
 	}
-	if len(o.PollFields) > 0 {
-		q.Add("poll.fields", strings.Join(pollFieldsToString(o.PollFields), ","))
+	if len(u.PollFields) > 0 {
+		q.Add("poll.fields", strings.Join(pollFieldsToString(u.PollFields), ","))
 	}
-	if len(o.TweetFields) > 0 {
-		q.Add("tweet.fields", strings.Join(tweetFieldsToString(o.TweetFields), ","))
+	if len(u.TweetFields) > 0 {
+		q.Add("tweet.fields", strings.Join(tweetFieldsToString(u.TweetFields), ","))
 	}
-	if len(o.UserFields) > 0 {
-		q.Add("user.fields", strings.Join(userFieldsToString(o.UserFields), ","))
+	if len(u.UserFields) > 0 {
+		q.Add("user.fields", strings.Join(userFieldsToString(u.UserFields), ","))
 	}
 	if len(q) > 0 {
 		req.URL.RawQuery = q.Encode()
diff --git a/timelines.go b/timeline.go
similarity index 69%
rename from timelines.go
rename to timeline.go
index 7e748ab..bc577a4 100644
--- a/timelines.go
+++ b/timeline.go
@@ -8,43 +8,46 @@ import (
 	"net/http"
 )
 
-func userTweetTimeline(ctx context.Context, c *client, id string, opt ...*UserTweetTimelineOption) (*UserTweetTimelineResponse, error) {
-	// check id
-	if len(id) == 0 {
-		return nil, errors.New("user tweet timeline: id parameter is required")
+func userMentionTimeline(ctx context.Context, c *client, userID string, opt ...*UserMentionTimelineOption) (*UserMentionTimelineResponse, error) {
+	if userID == "" {
+		return nil, errors.New("user mention timeline: userID parameter is required")
 	}
-	userTweetTimeline := timeline + "?id=" + id + "/tweets"
+	ep := fmt.Sprintf(userMentionTimelineURL, userID)
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, userTweetTimeline, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep, nil)
 	if err != nil {
-		return nil, fmt.Errorf("user tweet timeline new request with ctx: %w", err)
+		return nil, fmt.Errorf("user mention timeline new request with ctx: %w", err)
 	}
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
 
-	var uopt UserTweetTimelineOption
+	var uopt UserMentionTimelineOption
 	switch len(opt) {
 	case 0:
 		// do nothing
 	case 1:
 		uopt = *opt[0]
 	default:
-		return nil, errors.New("user tweet timeline: only one option is allowed")
+		return nil, errors.New("user mention timeline: only one option is allowed")
+	}
+	const minimumMaxResults = 5
+	if uopt.MaxResults < minimumMaxResults {
+		uopt.MaxResults = minimumMaxResults
 	}
 	uopt.addQuery(req)
 
 	resp, err := c.client.Do(req)
 	if err != nil {
-		return nil, fmt.Errorf("user tweet timeline response: %w", err)
+		return nil, fmt.Errorf("user mention timeline response: %w", err)
 	}
 	defer resp.Body.Close()
 
-	var timelines UserTweetTimelineResponse
+	var timelines UserMentionTimelineResponse
 	if err := json.NewDecoder(resp.Body).Decode(&timelines); err != nil {
-		return nil, fmt.Errorf("user tweet timeline decode: %w", err)
+		return nil, fmt.Errorf("user mention timeline decode: %w", err)
 	}
 	if resp.StatusCode != http.StatusOK {
 		return &timelines, &HTTPError{
-			APIName: "user tweet timeline",
+			APIName: "user mention timeline",
 			Status:  resp.Status,
 			URL:     req.URL.String(),
 		}
@@ -53,43 +56,46 @@ func userTweetTimeline(ctx context.Context, c *client, id string, opt ...*UserTw
 	return &timelines, nil
 }
 
-func userMentionTimeline(ctx context.Context, c *client, id string, opt ...*UserMentionTimelineOption) (*UserMentionTimelineResponse, error) {
-	// check id
-	if len(id) == 0 {
-		return nil, errors.New("user mention timeline: id parameter is required")
+func userTweetTimeline(ctx context.Context, c *client, userID string, opt ...*UserTweetTimelineOption) (*UserTweetTimelineResponse, error) {
+	if userID == "" {
+		return nil, errors.New("user tweet timeline: id parameter is required")
 	}
-	userMentionTimeline := timeline + "?id=" + id + "/mentions"
+	ep := fmt.Sprintf(userTweetTimelineURL, userID)
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, userMentionTimeline, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep, nil)
 	if err != nil {
-		return nil, fmt.Errorf("user mention timeline new request with ctx: %w", err)
+		return nil, fmt.Errorf("user tweet timeline new request with ctx: %w", err)
 	}
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
 
-	var uopt UserMentionTimelineOption
+	var uopt UserTweetTimelineOption
 	switch len(opt) {
 	case 0:
 		// do nothing
 	case 1:
 		uopt = *opt[0]
 	default:
-		return nil, errors.New("user mention timeline: only one option is allowed")
+		return nil, errors.New("user tweet timeline: only one option is allowed")
+	}
+	const minimumMaxResults = 5
+	if uopt.MaxResults < minimumMaxResults {
+		uopt.MaxResults = minimumMaxResults
 	}
 	uopt.addQuery(req)
 
 	resp, err := c.client.Do(req)
 	if err != nil {
-		return nil, fmt.Errorf("user mention timeline response: %w", err)
+		return nil, fmt.Errorf("user tweet timeline response: %w", err)
 	}
 	defer resp.Body.Close()
 
-	var timelines UserMentionTimelineResponse
+	var timelines UserTweetTimelineResponse
 	if err := json.NewDecoder(resp.Body).Decode(&timelines); err != nil {
-		return nil, fmt.Errorf("user mention timeline decode: %w", err)
+		return nil, fmt.Errorf("user tweet timeline decode: %w", err)
 	}
 	if resp.StatusCode != http.StatusOK {
 		return &timelines, &HTTPError{
-			APIName: "user mention timeline",
+			APIName: "user tweet timeline",
 			Status:  resp.Status,
 			URL:     req.URL.String(),
 		}
diff --git a/timelines_test.go b/timeline_test.go
similarity index 100%
rename from timelines_test.go
rename to timeline_test.go
diff --git a/tweet.go b/tweet.go
index 2a14cd8..c9dc686 100644
--- a/tweet.go
+++ b/tweet.go
@@ -156,7 +156,7 @@ type TweetWithheld struct {
 	CountryCodes []string `json:"country_codes"`
 }
 
-type TweetLookUpResponse struct {
+type TweetsResponse struct {
 	Tweets   []*Tweet            `json:"data"`
 	Includes *TweetIncludes      `json:"includes,omitempty"`
 	Errors   []*APIResponseError `json:"errors,omitempty"`
@@ -165,10 +165,13 @@ type TweetLookUpResponse struct {
 	Type     string              `json:"type,omitempty"`
 }
 
-type TweetLookUpByIDResponse struct {
+type TweetResponse struct {
 	Tweet    *Tweet              `json:"data"`
 	Includes *TweetIncludes      `json:"includes,omitempty"`
 	Errors   []*APIResponseError `json:"errors,omitempty"`
+	Title    string              `json:"title,omitempty"`
+	Detail   string              `json:"detail,omitempty"`
+	Type     string              `json:"type,omitempty"`
 }
 
 type TweetIncludes struct {
@@ -184,6 +187,9 @@ type UserTweetTimelineResponse struct {
 	Includes *TweetIncludes      `json:"includes,omitempty"`
 	Errors   []*APIResponseError `json:"errors,omitempty"`
 	Meta     *UserTimelineMeta   `json:"meta"`
+	Title    string              `json:"title,omitempty"`
+	Detail   string              `json:"detail,omitempty"`
+	Type     string              `json:"type,omitempty"`
 }
 
 type UserMentionTimelineResponse struct {
@@ -191,6 +197,9 @@ type UserMentionTimelineResponse struct {
 	Includes *TweetIncludes      `json:"includes,omitempty"`
 	Errors   []*APIResponseError `json:"errors,omitempty"`
 	Meta     *UserTimelineMeta   `json:"meta"`
+	Title    string              `json:"title,omitempty"`
+	Detail   string              `json:"detail,omitempty"`
+	Type     string              `json:"type,omitempty"`
 }
 
 type UserTimelineMeta struct {
@@ -200,14 +209,17 @@ type UserTimelineMeta struct {
 	NextToken   string `json:"next_token"`
 }
 
-type TweetSearchResponse struct {
+type SearchTweetsResponse struct {
 	Tweets   []*Tweet            `json:"data"`
 	Includes *TweetIncludes      `json:"includes,omitempty"`
-	Meta     *TweetSearchMeta    `json:"meta"`
+	Meta     *SearchTweetsMeta   `json:"meta"`
 	Errors   []*APIResponseError `json:"errors,omitempty"`
+	Title    string              `json:"title,omitempty"`
+	Detail   string              `json:"detail,omitempty"`
+	Type     string              `json:"type,omitempty"`
 }
 
-type TweetSearchMeta struct {
+type SearchTweetsMeta struct {
 	ResultCount int    `json:"result_count"`
 	NewestID    string `json:"newest_id"`
 	OldestID    string `json:"oldest_id"`
@@ -229,11 +241,14 @@ type TweetCountsResponse struct {
 	Meta   *TweetCountMeta    `json:"meta"`
 }
 
-type RetweetsLookupResponse struct {
+type RetweetsResponse struct {
 	Users    []*User             `json:"data"`
 	Includes *TweetIncludes      `json:"includes,omitempty"`
 	Errors   []*APIResponseError `json:"errors,omitempty"`
 	Meta     *RetweetsLookupMeta `json:"meta"`
+	Title    string              `json:"title,omitempty"`
+	Detail   string              `json:"detail,omitempty"`
+	Type     string              `json:"type,omitempty"`
 }
 
 type RetweetsLookupMeta struct {
@@ -253,7 +268,7 @@ type FilteredRule struct {
 }
 
 type RetrieveStreamRulesMeta struct {
-	Sent string // TODO: Is it number ?
+	Sent string
 }
 
 type AddOrDeleteJSONBody struct {
@@ -277,7 +292,7 @@ type AddOrDeleteRulesResponse struct {
 }
 
 type AddOrDeleteRulesMeta struct {
-	Sent    string                  `json:"sent"` // TODO: Is it number ?
+	Sent    string                  `json:"sent"`
 	Summary *AddOrDeleteMetaSummary `json:"summary"`
 }
 
@@ -327,16 +342,16 @@ type TweetBody struct {
 	TweetID string `json:"tweet_id"`
 }
 
-type SampledStreamResponse struct {
+type VolumeStreamsResponse struct {
 	Tweet    *Tweet              `json:"data"`
 	Includes *TweetIncludes      `json:"includes,omitempty"`
 	Errors   []*APIResponseError `json:"errors,omitempty"`
 }
 
-type StreamResponse struct {
+type VolumeStreams struct {
 	client *http.Client
 	errCh  chan<- error
-	ch     chan<- SampledStreamResponse
+	ch     chan<- VolumeStreamsResponse
 	done   chan struct{}
 	wg     *sync.WaitGroup
 }
@@ -412,7 +427,7 @@ type LookUpUsersWhoLiked struct {
 	PinnedTweetID   string                            `json:"pinned_tweet_id,omitempty"`
 }
 
-type LookUpUsersWhoLikedResponse struct {
+type UsersLikingTweetResponse struct {
 	Users    []*LookUpUsersWhoLiked       `json:"data"`
 	Includes *LookUpUsersWhoLikedIncludes `json:"includes,omitempty"`
 	Meta     *LookUpUsersWhoLikedMeta     `json:"meta"`
diff --git a/tweet_counts.go b/tweet_counts.go
index 903f4a4..38d217a 100644
--- a/tweet_counts.go
+++ b/tweet_counts.go
@@ -8,20 +8,15 @@ import (
 	"net/http"
 )
 
-func countsRecentTweet(ctx context.Context, c *client, query string, opt ...*TweetCountsOption) (*TweetCountsResponse, error) {
-	switch {
-	case len(query) == 0:
-		return nil, errors.New("tweet counts: query parameter is required")
-	case tweetSearchMaxQueryLength < len(query):
-		return nil, errors.New("tweet counts: query parameter length is less than 512")
-	default:
+func countsRecentTweet(ctx context.Context, c *client, tweet string, opt ...*TweetCountsOption) (*TweetCountsResponse, error) {
+	if tweet == "" {
+		return nil, errors.New("counts recent tweets: tweet parameter is required")
 	}
+	ep := fmt.Sprintf(countsRecentTweetsURL, tweet)
 
-	recentTweetCounts := recentTweetCounts + "?query=" + query
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, recentTweetCounts, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep, nil)
 	if err != nil {
-		return nil, fmt.Errorf("tweet counts new request with ctx: %w", err)
+		return nil, fmt.Errorf("counts recent tweets new request with ctx: %w", err)
 	}
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
 
@@ -32,27 +27,27 @@ func countsRecentTweet(ctx context.Context, c *client, query string, opt ...*Twe
 	case 1:
 		topt = *opt[0]
 	default:
-		return nil, errors.New("tweet counts: only one option is allowed")
+		return nil, errors.New("counts recent tweets: only one option is allowed")
 	}
 	topt.addQuery(req)
 
 	resp, err := c.client.Do(req)
 	if err != nil {
-		return nil, fmt.Errorf("tweet counts response: %w", err)
+		return nil, fmt.Errorf("counts recent tweets: %w", err)
 	}
 	defer resp.Body.Close()
 
-	var tweet TweetCountsResponse
-	if err := json.NewDecoder(resp.Body).Decode(&tweet); err != nil {
-		return nil, fmt.Errorf("tweet counts decode: %w", err)
+	var tcr TweetCountsResponse
+	if err := json.NewDecoder(resp.Body).Decode(&tcr); err != nil {
+		return nil, fmt.Errorf("tweet counts: %w", err)
 	}
 	if resp.StatusCode != http.StatusOK {
-		return &tweet, &HTTPError{
-			APIName: "tweet counts",
+		return &tcr, &HTTPError{
+			APIName: "counts recent tweets",
 			Status:  resp.Status,
 			URL:     req.URL.String(),
 		}
 	}
 
-	return &tweet, nil
+	return &tcr, nil
 }
diff --git a/tweet_lookup.go b/tweet_lookup.go
index b721b57..8288461 100644
--- a/tweet_lookup.go
+++ b/tweet_lookup.go
@@ -8,55 +8,53 @@ import (
 	"net/http"
 )
 
-func lookUpTweets(ctx context.Context, c *client, ids []string, opt ...*TweetLookUpOption) (*TweetLookUpResponse, error) {
-	// check ids
+func retrieveMultipleTweets(ctx context.Context, c *client, tweetIDs []string, opt ...*RetriveTweetOption) (*TweetsResponse, error) {
 	switch {
-	case len(ids) == 0:
-		return nil, errors.New("tweet lookup: ids parameter is required")
-	case len(ids) > tweetLookUpMaxIDs:
-		return nil, errors.New("tweet lookup: ids parameter must be less than or equal to 100")
+	case len(tweetIDs) == 0:
+		return nil, errors.New("retrieve multiple tweets: tweet ids parameter is required")
+	case len(tweetIDs) > tweetLookUpMaxIDs:
+		return nil, errors.New("retrieve multiple tweets: tweet ids parameter must be less than or equal to 100")
 	default:
 	}
-	tweetLookUp := tweetLookUp + "?ids="
-	// join ids to url
-	for i, id := range ids {
-		if i+1 < len(ids) {
-			tweetLookUp += fmt.Sprintf("%s,", id)
+	ep := retrieveMultipleTweetsURL
+	for i, tid := range tweetIDs {
+		if i+1 < len(tweetIDs) {
+			ep += fmt.Sprintf("%s,", tid)
 		} else {
-			tweetLookUp += id
+			ep += tid
 		}
 	}
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, tweetLookUp, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep, nil)
 	if err != nil {
-		return nil, fmt.Errorf("tweet lookup new request with ctx: %w", err)
+		return nil, fmt.Errorf("retrieve multiple tweets new request with ctx: %w", err)
 	}
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
 
-	var topt TweetLookUpOption
+	var ropt RetriveTweetOption
 	switch len(opt) {
 	case 0:
 		// do nothing
 	case 1:
-		topt = *opt[0]
+		ropt = *opt[0]
 	default:
-		return nil, errors.New("tweet lookup: only one option is allowed")
+		return nil, errors.New("retrieve multiple tweets: only one option is allowed")
 	}
-	topt.addQuery(req)
+	ropt.addQuery(req)
 
 	resp, err := c.client.Do(req)
 	if err != nil {
-		return nil, fmt.Errorf("tweet lookup response: %w", err)
+		return nil, fmt.Errorf("retrieve multiple tweets response: %w", err)
 	}
 	defer resp.Body.Close()
 
-	var tweet TweetLookUpResponse
+	var tweet TweetsResponse
 	if err := json.NewDecoder(resp.Body).Decode(&tweet); err != nil {
-		return nil, fmt.Errorf("tweet lookup decode: %w", err)
+		return nil, fmt.Errorf("retrieve multiple tweets: %w", err)
 	}
 	if resp.StatusCode != http.StatusOK {
 		return &tweet, &HTTPError{
-			APIName: "tweet lookup",
+			APIName: "retrieve multiple tweets",
 			Status:  resp.Status,
 			URL:     req.URL.String(),
 		}
@@ -65,44 +63,44 @@ func lookUpTweets(ctx context.Context, c *client, ids []string, opt ...*TweetLoo
 	return &tweet, nil
 }
 
-func lookUpTweetByID(ctx context.Context, c *client, id string, opt ...*TweetLookUpOption) (*TweetLookUpByIDResponse, error) {
-	if id == "" {
-		return nil, errors.New("tweet lookup by id: id parameter is required")
+func retrieveSingleTweet(ctx context.Context, c *client, tweetID string, opt ...*RetriveTweetOption) (*TweetResponse, error) {
+	if tweetID == "" {
+		return nil, errors.New("retrieve single tweet: tweet id parameter is required")
 	}
-	tweetLookUpByID := tweetLookUp + "/" + id
+	ep := fmt.Sprintf(retrieveSingleTweetURL, tweetID)
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, tweetLookUpByID, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep, nil)
 	if err != nil {
-		return nil, fmt.Errorf("tweet lookup by id new request with ctx: %w", err)
+		return nil, fmt.Errorf("retrieve single tweet new request with ctx: %w", err)
 	}
 
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
 
-	var topt TweetLookUpOption
+	var ropt RetriveTweetOption
 	switch len(opt) {
 	case 0:
 		// do nothing
 	case 1:
-		topt = *opt[0]
+		ropt = *opt[0]
 	default:
-		return nil, errors.New("tweet lookup: only one option is allowed")
+		return nil, errors.New("retrieve single tweet: only one option is allowed")
 	}
-	topt.addQuery(req)
+	ropt.addQuery(req)
 
 	resp, err := c.client.Do(req)
 	if err != nil {
-		return nil, fmt.Errorf("tweet lookup by id response: %w", err)
+		return nil, fmt.Errorf("retrieve single tweet response: %w", err)
 	}
 
 	defer resp.Body.Close()
 
-	var tweet TweetLookUpByIDResponse
+	var tweet TweetResponse
 	if err := json.NewDecoder(resp.Body).Decode(&tweet); err != nil {
-		return nil, fmt.Errorf("tweet lookup by id decode: %w", err)
+		return nil, fmt.Errorf("retrieve single tweet: %w", err)
 	}
 	if resp.StatusCode != http.StatusOK {
 		return &tweet, &HTTPError{
-			APIName: "tweet lookup by id",
+			APIName: "retrieve single tweet",
 			Status:  resp.Status,
 			URL:     req.URL.String(),
 		}
diff --git a/tweet_option.go b/tweet_option.go
index 38e15f6..6ffc83d 100644
--- a/tweet_option.go
+++ b/tweet_option.go
@@ -7,7 +7,7 @@ import (
 	"time"
 )
 
-type TweetLookUpOption struct {
+type RetriveTweetOption struct {
 	Expansions  []Expansion
 	MediaFields []MediaField
 	PlaceFields []PlaceField
@@ -16,93 +16,25 @@ type TweetLookUpOption struct {
 	UserFields  []UserField
 }
 
-func (t *TweetLookUpOption) addQuery(req *http.Request) {
+func (r RetriveTweetOption) addQuery(req *http.Request) {
 	q := req.URL.Query()
-	if len(t.Expansions) > 0 {
-		q.Add("expansions", strings.Join(expansionsToString(t.Expansions), ","))
+	if len(r.Expansions) > 0 {
+		q.Add("expansions", strings.Join(expansionsToString(r.Expansions), ","))
 	}
-	if len(t.MediaFields) > 0 {
-		q.Add("media.fields", strings.Join(mediaFieldsToString(t.MediaFields), ","))
+	if len(r.MediaFields) > 0 {
+		q.Add("media.fields", strings.Join(mediaFieldsToString(r.MediaFields), ","))
 	}
-	if len(t.PlaceFields) > 0 {
-		q.Add("place.fields", strings.Join(placeFieldsToString(t.PlaceFields), ","))
+	if len(r.PlaceFields) > 0 {
+		q.Add("place.fields", strings.Join(placeFieldsToString(r.PlaceFields), ","))
 	}
-	if len(t.PollFields) > 0 {
-		q.Add("poll.fields", strings.Join(pollFieldsToString(t.PollFields), ","))
+	if len(r.PollFields) > 0 {
+		q.Add("poll.fields", strings.Join(pollFieldsToString(r.PollFields), ","))
 	}
-	if len(t.TweetFields) > 0 {
-		q.Add("tweet.fields", strings.Join(tweetFieldsToString(t.TweetFields), ","))
+	if len(r.TweetFields) > 0 {
+		q.Add("tweet.fields", strings.Join(tweetFieldsToString(r.TweetFields), ","))
 	}
-	if len(t.UserFields) > 0 {
-		q.Add("user.fields", strings.Join(userFieldsToString(t.UserFields), ","))
-	}
-	if len(q) > 0 {
-		req.URL.RawQuery = q.Encode()
-	}
-}
-
-func tweetFieldsToString(tfs []TweetField) []string {
-	slice := make([]string, len(tfs))
-	for i, tf := range tfs {
-		slice[i] = string(tf)
-	}
-	return slice
-}
-
-type TweetSearchOption struct {
-	Expansions  []Expansion
-	MediaFields []MediaField
-	PlaceFields []PlaceField
-	PollFields  []PollField
-	TweetFields []TweetField
-	UserFields  []UserField
-	StartTime   time.Time
-	EndTime     time.Time
-	MaxResults  int
-	NextToken   string
-	SinceID     string
-	UntilID     string
-}
-
-func (t TweetSearchOption) addQuery(req *http.Request) {
-	q := req.URL.Query()
-	if len(t.Expansions) > 0 {
-		q.Add("expansions", strings.Join(expansionsToString(t.Expansions), ","))
-	}
-	if len(t.MediaFields) > 0 {
-		q.Add("media.fields", strings.Join(mediaFieldsToString(t.MediaFields), ","))
-	}
-	if len(t.PlaceFields) > 0 {
-		q.Add("place.fields", strings.Join(placeFieldsToString(t.PlaceFields), ","))
-	}
-	if len(t.PollFields) > 0 {
-		q.Add("poll.fields", strings.Join(pollFieldsToString(t.PollFields), ","))
-	}
-	if len(t.TweetFields) > 0 {
-		q.Add("tweet.fields", strings.Join(tweetFieldsToString(t.TweetFields), ","))
-	}
-	if len(t.UserFields) > 0 {
-		q.Add("user.fields", strings.Join(userFieldsToString(t.UserFields), ","))
-	}
-	if !t.StartTime.IsZero() {
-		// YYYY-MM-DDTHH:mm:ssZ (ISO 8601/RFC 3339).
-		q.Add("start_time", t.StartTime.Format(time.RFC3339))
-	}
-	if !t.EndTime.IsZero() {
-		// YYYY-MM-DDTHH:mm:ssZ (ISO 8601/RFC 3339).
-		q.Add("end_time", t.EndTime.Format(time.RFC3339))
-	}
-	if t.MaxResults > 0 {
-		q.Add("max_results", strconv.Itoa(t.MaxResults))
-	}
-	if len(t.NextToken) > 0 {
-		q.Add("next_token", t.NextToken)
-	}
-	if len(t.SinceID) > 0 {
-		q.Add("since_id", t.SinceID)
-	}
-	if len(t.UntilID) > 0 {
-		q.Add("until_id", t.UntilID)
+	if len(r.UserFields) > 0 {
+		q.Add("user.fields", strings.Join(userFieldsToString(r.UserFields), ","))
 	}
 	if len(q) > 0 {
 		req.URL.RawQuery = q.Encode()
@@ -110,61 +42,61 @@ func (t TweetSearchOption) addQuery(req *http.Request) {
 }
 
 type UserTweetTimelineOption struct {
+	EndTime         time.Time
+	Exclude         []Exclude
 	Expansions      []Expansion
+	MaxResults      int
 	MediaFields     []MediaField
+	PaginationToken string
 	PlaceFields     []PlaceField
 	PollFields      []PollField
-	TweetFields     []TweetField
-	UserFields      []UserField
-	Exclude         []Exclude
-	StartTime       time.Time
-	EndTime         time.Time
-	MaxResults      int
-	PaginationToken string
 	SinceID         string
+	StartTime       time.Time
+	TweetFields     []TweetField
 	UntilID         string
+	UserFields      []UserField
 }
 
-func (t UserTweetTimelineOption) addQuery(req *http.Request) {
+func (u UserTweetTimelineOption) addQuery(req *http.Request) {
 	q := req.URL.Query()
-	if len(t.Expansions) > 0 {
-		q.Add("expansions", strings.Join(expansionsToString(t.Expansions), ","))
+	if !u.EndTime.IsZero() {
+		q.Add("end_time", u.EndTime.Format(time.RFC3339))
 	}
-	if len(t.MediaFields) > 0 {
-		q.Add("media.fields", strings.Join(mediaFieldsToString(t.MediaFields), ","))
+	if len(u.Exclude) > 0 {
+		q.Add("exclude", strings.Join(excludeToString(u.Exclude), ","))
 	}
-	if len(t.PlaceFields) > 0 {
-		q.Add("place.fields", strings.Join(placeFieldsToString(t.PlaceFields), ","))
+	if len(u.Expansions) > 0 {
+		q.Add("expansions", strings.Join(expansionsToString(u.Expansions), ","))
 	}
-	if len(t.PollFields) > 0 {
-		q.Add("poll.fields", strings.Join(pollFieldsToString(t.PollFields), ","))
+	if u.MaxResults > 0 {
+		q.Add("max_results", strconv.Itoa(u.MaxResults))
 	}
-	if len(t.TweetFields) > 0 {
-		q.Add("tweet.fields", strings.Join(tweetFieldsToString(t.TweetFields), ","))
+	if len(u.MediaFields) > 0 {
+		q.Add("media.fields", strings.Join(mediaFieldsToString(u.MediaFields), ","))
 	}
-	if len(t.UserFields) > 0 {
-		q.Add("user.fields", strings.Join(userFieldsToString(t.UserFields), ","))
+	if u.PaginationToken != "" {
+		q.Add("pagination_token", u.PaginationToken)
 	}
-	if len(t.Exclude) > 0 {
-		q.Add("exclude", strings.Join(excludeToString(t.Exclude), ","))
+	if len(u.PlaceFields) > 0 {
+		q.Add("place.fields", strings.Join(placeFieldsToString(u.PlaceFields), ","))
 	}
-	if !t.StartTime.IsZero() {
-		q.Add("start_time", t.StartTime.Format(time.RFC3339))
+	if len(u.PollFields) > 0 {
+		q.Add("poll.fields", strings.Join(pollFieldsToString(u.PollFields), ","))
 	}
-	if !t.EndTime.IsZero() {
-		q.Add("end_time", t.EndTime.Format(time.RFC3339))
+	if u.SinceID != "" {
+		q.Add("since_id", u.SinceID)
 	}
-	if t.MaxResults > 0 {
-		q.Add("max_results", strconv.Itoa(t.MaxResults))
+	if !u.StartTime.IsZero() {
+		q.Add("start_time", u.StartTime.Format(time.RFC3339))
 	}
-	if len(t.PaginationToken) > 0 {
-		q.Add("pagination_token", t.PaginationToken)
+	if len(u.TweetFields) > 0 {
+		q.Add("tweet.fields", strings.Join(tweetFieldsToString(u.TweetFields), ","))
 	}
-	if len(t.SinceID) > 0 {
-		q.Add("since_id", t.SinceID)
+	if u.UntilID != "" {
+		q.Add("until_id", u.UntilID)
 	}
-	if len(t.UntilID) > 0 {
-		q.Add("until_id", t.UntilID)
+	if len(u.UserFields) > 0 {
+		q.Add("user.fields", strings.Join(userFieldsToString(u.UserFields), ","))
 	}
 	if len(q) > 0 {
 		req.URL.RawQuery = q.Encode()
@@ -172,90 +104,113 @@ func (t UserTweetTimelineOption) addQuery(req *http.Request) {
 }
 
 type UserMentionTimelineOption struct {
+	EndTime         time.Time
 	Expansions      []Expansion
+	MaxResults      int
 	MediaFields     []MediaField
+	PaginationToken string
 	PlaceFields     []PlaceField
 	PollFields      []PollField
-	TweetFields     []TweetField
-	UserFields      []UserField
-	StartTime       time.Time
-	EndTime         time.Time
-	MaxResults      int
-	PaginationToken string
 	SinceID         string
+	StartTime       time.Time
+	TweetFields     []TweetField
 	UntilID         string
+	UserFields      []UserField
 }
 
-func (t UserMentionTimelineOption) addQuery(req *http.Request) {
+func (u UserMentionTimelineOption) addQuery(req *http.Request) {
 	q := req.URL.Query()
-	if len(t.Expansions) > 0 {
-		q.Add("expansions", strings.Join(expansionsToString(t.Expansions), ","))
+	if !u.EndTime.IsZero() {
+		q.Add("end_time", u.EndTime.Format(time.RFC3339))
 	}
-	if len(t.MediaFields) > 0 {
-		q.Add("media.fields", strings.Join(mediaFieldsToString(t.MediaFields), ","))
+	if len(u.Expansions) > 0 {
+		q.Add("expansions", strings.Join(expansionsToString(u.Expansions), ","))
 	}
-	if len(t.PlaceFields) > 0 {
-		q.Add("place.fields", strings.Join(placeFieldsToString(t.PlaceFields), ","))
+	if u.MaxResults > 0 {
+		q.Add("max_results", strconv.Itoa(u.MaxResults))
 	}
-	if len(t.PollFields) > 0 {
-		q.Add("poll.fields", strings.Join(pollFieldsToString(t.PollFields), ","))
+	if len(u.MediaFields) > 0 {
+		q.Add("media.fields", strings.Join(mediaFieldsToString(u.MediaFields), ","))
 	}
-	if len(t.TweetFields) > 0 {
-		q.Add("tweet.fields", strings.Join(tweetFieldsToString(t.TweetFields), ","))
+	if u.PaginationToken != "" {
+		q.Add("pagination_token", u.PaginationToken)
 	}
-	if len(t.UserFields) > 0 {
-		q.Add("user.fields", strings.Join(userFieldsToString(t.UserFields), ","))
+	if len(u.PlaceFields) > 0 {
+		q.Add("place.fields", strings.Join(placeFieldsToString(u.PlaceFields), ","))
 	}
-	if !t.StartTime.IsZero() {
-		q.Add("start_time", t.StartTime.Format(time.RFC3339))
+	if len(u.PollFields) > 0 {
+		q.Add("poll.fields", strings.Join(pollFieldsToString(u.PollFields), ","))
 	}
-	if !t.EndTime.IsZero() {
-		q.Add("end_time", t.EndTime.Format(time.RFC3339))
+	if u.SinceID != "" {
+		q.Add("since_id", u.SinceID)
 	}
-	if t.MaxResults > 0 {
-		q.Add("max_results", strconv.Itoa(t.MaxResults))
+	if !u.StartTime.IsZero() {
+		q.Add("start_time", u.StartTime.Format(time.RFC3339))
 	}
-	if len(t.PaginationToken) > 0 {
-		q.Add("pagination_token", t.PaginationToken)
+	if len(u.TweetFields) > 0 {
+		q.Add("tweet.fields", strings.Join(tweetFieldsToString(u.TweetFields), ","))
 	}
-	if len(t.SinceID) > 0 {
-		q.Add("since_id", t.SinceID)
+	if u.UntilID != "" {
+		q.Add("until_id", u.UntilID)
 	}
-	if len(t.UntilID) > 0 {
-		q.Add("until_id", t.UntilID)
+	if len(u.UserFields) > 0 {
+		q.Add("user.fields", strings.Join(userFieldsToString(u.UserFields), ","))
 	}
 	if len(q) > 0 {
 		req.URL.RawQuery = q.Encode()
 	}
 }
 
-type SampledStreamOpts struct {
-	// BackfillMinutes int `json:"backfill_minutes"` // This feature is currently only available to the Academic Research product track.
+type SearchTweetsOption struct {
+	EndTime     time.Time
 	Expansions  []Expansion
+	MaxResults  int
 	MediaFields []MediaField
+	NextToken   string
 	PlaceFields []PlaceField
 	PollFields  []PollField
+	SinceID     string
+	StartTime   time.Time
 	TweetFields []TweetField
+	UntilID     string
 	UserFields  []UserField
 }
 
-func (t SampledStreamOpts) addQuery(req *http.Request) {
+func (t SearchTweetsOption) addQuery(req *http.Request) {
 	q := req.URL.Query()
+	if !t.EndTime.IsZero() {
+		q.Add("end_time", t.EndTime.Format(time.RFC3339))
+	}
 	if len(t.Expansions) > 0 {
 		q.Add("expansions", strings.Join(expansionsToString(t.Expansions), ","))
 	}
+	if t.MaxResults > 0 {
+		q.Add("max_results", strconv.Itoa(t.MaxResults))
+	}
 	if len(t.MediaFields) > 0 {
 		q.Add("media.fields", strings.Join(mediaFieldsToString(t.MediaFields), ","))
 	}
+	if t.NextToken != "" {
+		q.Add("next_token", t.NextToken)
+	}
 	if len(t.PlaceFields) > 0 {
 		q.Add("place.fields", strings.Join(placeFieldsToString(t.PlaceFields), ","))
 	}
 	if len(t.PollFields) > 0 {
 		q.Add("poll.fields", strings.Join(pollFieldsToString(t.PollFields), ","))
 	}
+	if t.SinceID != "" {
+		q.Add("since_id", t.SinceID)
+	}
+	if !t.StartTime.IsZero() {
+		q.Add("start_time", t.StartTime.Format(time.RFC3339))
+	}
 	if len(t.TweetFields) > 0 {
 		q.Add("tweet.fields", strings.Join(tweetFieldsToString(t.TweetFields), ","))
 	}
+	if t.UntilID != "" {
+		q.Add("until_id", t.UntilID)
+	}
 	if len(t.UserFields) > 0 {
 		q.Add("user.fields", strings.Join(userFieldsToString(t.UserFields), ","))
 	}
@@ -296,41 +251,36 @@ func (t *TweetCountsOption) addQuery(req *http.Request) {
 	}
 }
 
-type LookUpUsersWhoLikedOpts struct {
-	Expansions  []Expansion
-	MediaFields []MediaField
-	PlaceFields []PlaceField
-	PollFields  []PollField
-	TweetFields []TweetField
-	UserFields  []UserField
+type AddOrDeleteRulesOption struct {
+	DryRun bool // If it is true, test a the syntax of your rule without submitting it
 }
 
-func (l *LookUpUsersWhoLikedOpts) addQuery(req *http.Request) {
+func (t *AddOrDeleteRulesOption) addQuery(req *http.Request) {
 	q := req.URL.Query()
-	if len(l.Expansions) > 0 {
-		q.Add("expansions", strings.Join(expansionsToString(l.Expansions), ","))
-	}
-	if len(l.MediaFields) > 0 {
-		q.Add("media.fields", strings.Join(mediaFieldsToString(l.MediaFields), ","))
-	}
-	if len(l.PlaceFields) > 0 {
-		q.Add("place.fields", strings.Join(placeFieldsToString(l.PlaceFields), ","))
-	}
-	if len(l.PollFields) > 0 {
-		q.Add("poll.fields", strings.Join(pollFieldsToString(l.PollFields), ","))
+	if t.DryRun {
+		q.Add("dry_run", strconv.FormatBool(t.DryRun))
 	}
-	if len(l.TweetFields) > 0 {
-		q.Add("tweet.fields", strings.Join(tweetFieldsToString(l.TweetFields), ","))
+	if len(q) > 0 {
+		req.URL.RawQuery = q.Encode()
 	}
-	if len(l.UserFields) > 0 {
-		q.Add("user.fields", strings.Join(userFieldsToString(l.UserFields), ","))
+}
+
+type RetrieveStreamRulesOption struct {
+	IDs []string
+}
+
+func (t *RetrieveStreamRulesOption) addQuery(req *http.Request) {
+	q := req.URL.Query()
+	if len(t.IDs) > 0 {
+		q.Add("ids", strings.Join(t.IDs, ","))
 	}
 	if len(q) > 0 {
 		req.URL.RawQuery = q.Encode()
 	}
 }
 
-type RetweetsLookupOpts struct {
+type ConnectToStreamOption struct {
+	// BackfillMinutes int // This feature is currently only available to the Academic Research product track.
 	Expansions  []Expansion
 	MediaFields []MediaField
 	PlaceFields []PlaceField
@@ -339,7 +289,7 @@ type RetweetsLookupOpts struct {
 	UserFields  []UserField
 }
 
-func (t RetweetsLookupOpts) addQuery(req *http.Request) {
+func (t *ConnectToStreamOption) addQuery(req *http.Request) {
 	q := req.URL.Query()
 	if len(t.Expansions) > 0 {
 		q.Add("expansions", strings.Join(expansionsToString(t.Expansions), ","))
@@ -364,36 +314,76 @@ func (t RetweetsLookupOpts) addQuery(req *http.Request) {
 	}
 }
 
-type RetrieveStreamRulesOption struct {
-	IDs []string
+type VolumeStreamsOption struct {
+	// BackfillMinutes int // This feature is currently only available to the Academic Research product track.
+	Expansions  []Expansion
+	MediaFields []MediaField
+	PlaceFields []PlaceField
+	PollFields  []PollField
+	TweetFields []TweetField
+	UserFields  []UserField
 }
 
-func (t *RetrieveStreamRulesOption) addQuery(req *http.Request) {
+func (v VolumeStreamsOption) addQuery(req *http.Request) {
 	q := req.URL.Query()
-	if len(t.IDs) > 0 {
-		q.Add("ids", strings.Join(t.IDs, ","))
+	if len(v.Expansions) > 0 {
+		q.Add("expansions", strings.Join(expansionsToString(v.Expansions), ","))
+	}
+	if len(v.MediaFields) > 0 {
+		q.Add("media.fields", strings.Join(mediaFieldsToString(v.MediaFields), ","))
+	}
+	if len(v.PlaceFields) > 0 {
+		q.Add("place.fields", strings.Join(placeFieldsToString(v.PlaceFields), ","))
+	}
+	if len(v.PollFields) > 0 {
+		q.Add("poll.fields", strings.Join(pollFieldsToString(v.PollFields), ","))
+	}
+	if len(v.TweetFields) > 0 {
+		q.Add("tweet.fields", strings.Join(tweetFieldsToString(v.TweetFields), ","))
+	}
+	if len(v.UserFields) > 0 {
+		q.Add("user.fields", strings.Join(userFieldsToString(v.UserFields), ","))
 	}
 	if len(q) > 0 {
 		req.URL.RawQuery = q.Encode()
 	}
 }
 
-type AddOrDeleteRulesOption struct {
-	DryRun bool // If it is true, test a the syntax of your rule without submitting it
+type UsersLikingTweetOption struct {
+	Expansions  []Expansion
+	MediaFields []MediaField
+	PlaceFields []PlaceField
+	PollFields  []PollField
+	TweetFields []TweetField
+	UserFields  []UserField
 }
 
-func (t *AddOrDeleteRulesOption) addQuery(req *http.Request) {
+func (u *UsersLikingTweetOption) addQuery(req *http.Request) {
 	q := req.URL.Query()
-	if t.DryRun {
-		q.Add("dry_run", strconv.FormatBool(t.DryRun))
+	if len(u.Expansions) > 0 {
+		q.Add("expansions", strings.Join(expansionsToString(u.Expansions), ","))
+	}
+	if len(u.MediaFields) > 0 {
+		q.Add("media.fields", strings.Join(mediaFieldsToString(u.MediaFields), ","))
+	}
+	if len(u.PlaceFields) > 0 {
+		q.Add("place.fields", strings.Join(placeFieldsToString(u.PlaceFields), ","))
+	}
+	if len(u.PollFields) > 0 {
+		q.Add("poll.fields", strings.Join(pollFieldsToString(u.PollFields), ","))
+	}
+	if len(u.TweetFields) > 0 {
+		q.Add("tweet.fields", strings.Join(tweetFieldsToString(u.TweetFields), ","))
+	}
+	if len(u.UserFields) > 0 {
+		q.Add("user.fields", strings.Join(userFieldsToString(u.UserFields), ","))
 	}
 	if len(q) > 0 {
 		req.URL.RawQuery = q.Encode()
 	}
 }
 
-type ConnectToStreamOption struct {
-	// BackfillMinutes int `json:"backfill_minutes"` // This feature is currently only available to the Academic Research product track.
+type RetweetsLookupOption struct {
 	Expansions  []Expansion
 	MediaFields []MediaField
 	PlaceFields []PlaceField
@@ -402,27 +392,35 @@ type ConnectToStreamOption struct {
 	UserFields  []UserField
 }
 
-func (t *ConnectToStreamOption) addQuery(req *http.Request) {
+func (r RetweetsLookupOption) addQuery(req *http.Request) {
 	q := req.URL.Query()
-	if len(t.Expansions) > 0 {
-		q.Add("expansions", strings.Join(expansionsToString(t.Expansions), ","))
+	if len(r.Expansions) > 0 {
+		q.Add("expansions", strings.Join(expansionsToString(r.Expansions), ","))
 	}
-	if len(t.MediaFields) > 0 {
-		q.Add("media.fields", strings.Join(mediaFieldsToString(t.MediaFields), ","))
+	if len(r.MediaFields) > 0 {
+		q.Add("media.fields", strings.Join(mediaFieldsToString(r.MediaFields), ","))
 	}
-	if len(t.PlaceFields) > 0 {
-		q.Add("place.fields", strings.Join(placeFieldsToString(t.PlaceFields), ","))
+	if len(r.PlaceFields) > 0 {
+		q.Add("place.fields", strings.Join(placeFieldsToString(r.PlaceFields), ","))
 	}
-	if len(t.PollFields) > 0 {
-		q.Add("poll.fields", strings.Join(pollFieldsToString(t.PollFields), ","))
+	if len(r.PollFields) > 0 {
+		q.Add("poll.fields", strings.Join(pollFieldsToString(r.PollFields), ","))
 	}
-	if len(t.TweetFields) > 0 {
-		q.Add("tweet.fields", strings.Join(tweetFieldsToString(t.TweetFields), ","))
+	if len(r.TweetFields) > 0 {
+		q.Add("tweet.fields", strings.Join(tweetFieldsToString(r.TweetFields), ","))
 	}
-	if len(t.UserFields) > 0 {
-		q.Add("user.fields", strings.Join(userFieldsToString(t.UserFields), ","))
+	if len(r.UserFields) > 0 {
+		q.Add("user.fields", strings.Join(userFieldsToString(r.UserFields), ","))
 	}
 	if len(q) > 0 {
 		req.URL.RawQuery = q.Encode()
 	}
 }
+
+func tweetFieldsToString(tfs []TweetField) []string {
+	slice := make([]string, len(tfs))
+	for i, tf := range tfs {
+		slice[i] = string(tf)
+	}
+	return slice
+}
diff --git a/user.go b/user.go
index 5378982..12f39a8 100644
--- a/user.go
+++ b/user.go
@@ -103,29 +103,17 @@ type UserIncludes struct {
 	Tweets []*Tweet
 }
 
-type UserLookUpResponse struct {
+type UsersResponse struct {
 	Users    []*User             `json:"data"`
 	Includes *UserIncludes       `json:"includes,omitempty"`
 	Errors   []*APIResponseError `json:"errors,omitempty"`
-}
-
-type UserLookUpByIDResponse struct {
-	User     *User               `json:"data"`
-	Includes *UserIncludes       `json:"includes,omitempty"`
-	Errors   []*APIResponseError `json:"errors,omitempty"`
-}
-
-type UserLookUpByUserNameResponse struct {
-	User     *User               `json:"data"`
-	Includes *UserIncludes       `json:"includes,omitempty"`
-	Errors   []*APIResponseError `json:"errors,omitempty"`
 	Title    string              `json:"title,omitempty"`
 	Detail   string              `json:"detail,omitempty"`
 	Type     string              `json:"type,omitempty"`
 }
 
-type UsersLookUpByUserNamesResponse struct {
-	Users    []*User             `json:"data"`
+type UserResponse struct {
+	User     *User               `json:"data"`
 	Includes *UserIncludes       `json:"includes,omitempty"`
 	Errors   []*APIResponseError `json:"errors,omitempty"`
 	Title    string              `json:"title,omitempty"`
diff --git a/user_lookup.go b/user_lookup.go
index e9b6d97..04836e0 100644
--- a/user_lookup.go
+++ b/user_lookup.go
@@ -8,210 +8,206 @@ import (
 	"net/http"
 )
 
-func lookUpUsers(ctx context.Context, c *client, ids []string, opt ...*UserLookUpOption) (*UserLookUpResponse, error) {
-	// check ids
+func retrieveMultipleUsersWithIDs(ctx context.Context, c *client, userIDs []string, opt ...*RetrieveUserOption) (*UsersResponse, error) {
 	switch {
-	case len(ids) == 0:
-		return nil, errors.New("user lookup: ids parameter is required")
-	case len(ids) > userLookUpMaxIDs:
-		return nil, errors.New("user lookup: ids parameter must be less than or equal to 100")
+	case len(userIDs) == 0:
+		return nil, errors.New("retrieve multiple users with ids: ids parameter is required")
+	case len(userIDs) > userLookUpMaxIDs:
+		return nil, errors.New("retrieve multiple users with ids: ids parameter must be less than or equal to 100")
 	default:
 	}
-	lookUpUsers := userLookUp + "?ids="
-	// join ids to url
-	for i, id := range ids {
-		if i+1 < len(ids) {
-			lookUpUsers += fmt.Sprintf("%s,", id)
+	ep := retrieveMultipleUsersWithIDsURL
+	for i, uid := range userIDs {
+		if i+1 < len(userIDs) {
+			ep += fmt.Sprintf("%s,", uid)
 		} else {
-			lookUpUsers += id
+			ep += uid
 		}
 	}
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, lookUpUsers, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep, nil)
 	if err != nil {
-		return nil, fmt.Errorf("user lookup new request with ctx: %w", err)
+		return nil, fmt.Errorf("retrieve multiple users with ids new request with ctx: %w", err)
 	}
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
 
-	var topt UserLookUpOption
+	var ropt RetrieveUserOption
 	switch len(opt) {
 	case 0:
 		// do nothing
 	case 1:
-		topt = *opt[0]
+		ropt = *opt[0]
 	default:
-		return nil, errors.New("user lookup: only one option is allowed")
+		return nil, errors.New("retrieve multiple users with ids: only one option is allowed")
 	}
-	topt.addQuery(req)
+	ropt.addQuery(req)
 
 	resp, err := c.client.Do(req)
 	if err != nil {
-		return nil, fmt.Errorf("user lookup response: %w", err)
+		return nil, fmt.Errorf("retrieve multiple users with ids response: %w", err)
 	}
 	defer resp.Body.Close()
 
-	var user UserLookUpResponse
-	if err := json.NewDecoder(resp.Body).Decode(&user); err != nil {
-		return nil, fmt.Errorf("user lookup decode: %w", err)
+	var ur UsersResponse
+	if err := json.NewDecoder(resp.Body).Decode(&ur); err != nil {
+		return nil, fmt.Errorf("retrieve multiple users with ids decode: %w", err)
 	}
 	if resp.StatusCode != http.StatusOK {
-		return &user, &HTTPError{
+		return &ur, &HTTPError{
 			APIName: "user lookup",
 			Status:  resp.Status,
 			URL:     req.URL.String(),
 		}
 	}
 
-	return &user, nil
+	return &ur, nil
 }
 
-func lookUpUserByID(ctx context.Context, c *client, id string, opt ...*UserLookUpOption) (*UserLookUpByIDResponse, error) {
-	if id == "" {
-		return nil, errors.New("user lookup by id: id parameter is required")
+func retrieveSingleUserWithID(ctx context.Context, c *client, userID string, opt ...*RetrieveUserOption) (*UserResponse, error) {
+	if userID == "" {
+		return nil, errors.New("retrieve single user with id: user id is required")
 	}
-	lookUpUserByID := userLookUp + "/" + id
+	ep := fmt.Sprintf(retrieveSingleUserWithIDURL, userID)
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, lookUpUserByID, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep, nil)
 	if err != nil {
-		return nil, fmt.Errorf("user lookup by id new request with ctx: %w", err)
+		return nil, fmt.Errorf("retrieve single user with id new request with ctx: %w", err)
 	}
 
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
 
-	var topt UserLookUpOption
+	var ropt RetrieveUserOption
 	switch len(opt) {
 	case 0:
 		// do nothing
 	case 1:
-		topt = *opt[0]
+		ropt = *opt[0]
 	default:
-		return nil, errors.New("user lookup: only one option is allowed")
+		return nil, errors.New("retrieve single user with id: only one option is allowed")
 	}
-	topt.addQuery(req)
+	ropt.addQuery(req)
 
 	resp, err := c.client.Do(req)
 	if err != nil {
-		return nil, fmt.Errorf("user lookup by id response: %w", err)
+		return nil, fmt.Errorf("retrieve single user with id response: %w", err)
 	}
 
 	defer resp.Body.Close()
 
-	var user UserLookUpByIDResponse
-	if err := json.NewDecoder(resp.Body).Decode(&user); err != nil {
-		return nil, fmt.Errorf("user lookup by id decode: %w", err)
+	var ur UserResponse
+	if err := json.NewDecoder(resp.Body).Decode(&ur); err != nil {
+		return nil, fmt.Errorf("retrieve single user with id decode: %w", err)
 	}
 	if resp.StatusCode != http.StatusOK {
-		return &user, &HTTPError{
-			APIName: "user lookup by id",
+		return &ur, &HTTPError{
+			APIName: "retrieve single user with id",
 			Status:  resp.Status,
 			URL:     req.URL.String(),
 		}
 	}
 
-	return &user, nil
+	return &ur, nil
 }
 
-func lookUpUserByUserName(ctx context.Context, c *client, name string, opt ...*UserLookUpOption) (*UserLookUpByUserNameResponse, error) {
-	if name == "" {
-		return nil, errors.New("user lookup by username: name parameter is required")
+func retrieveMultipleUsersWithUserNames(ctx context.Context, c *client, userNames []string, opt ...*RetrieveUserOption) (*UsersResponse, error) {
+	switch {
+	case len(userNames) == 0:
+		return nil, errors.New("retrieve multiple users with user names: user names parameter is required")
+	case len(userNames) > userLookUpMaxIDs:
+		return nil, errors.New("retrieve multiple users with user names: user names parameter must be less than or equal to 100")
+	default:
+	}
+	ep := retrieveMultipleUsersWithUserNamesURL
+	for i, un := range userNames {
+		if i+1 < len(un) {
+			ep += fmt.Sprintf("%s,", un)
+		} else {
+			ep += un
+		}
 	}
-	lookUpUserByUserName := userLookUp + "/by/username/" + name
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, lookUpUserByUserName, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep, nil)
 	if err != nil {
-		return nil, fmt.Errorf("user lookup by username new request with ctx: %w", err)
+		return nil, fmt.Errorf("retrieve multiple users with user names new request with ctx: %w", err)
 	}
 
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
 
-	var topt UserLookUpOption
+	var ropt RetrieveUserOption
 	switch len(opt) {
 	case 0:
 		// do nothing
 	case 1:
-		topt = *opt[0]
+		ropt = *opt[0]
 	default:
-		return nil, errors.New("user lookup by username: only one option is allowed")
+		return nil, errors.New("retrieve multiple users with user names: only one option is allowed")
 	}
-	topt.addQuery(req)
+	ropt.addQuery(req)
 
 	resp, err := c.client.Do(req)
 	if err != nil {
-		return nil, fmt.Errorf("user lookup by username response: %w", err)
+		return nil, fmt.Errorf("retrieve multiple users with user names response: %w", err)
 	}
 
 	defer resp.Body.Close()
 
-	var user UserLookUpByUserNameResponse
-	if err := json.NewDecoder(resp.Body).Decode(&user); err != nil {
-		return nil, fmt.Errorf("user lookup by username decode: %w", err)
+	var ur UsersResponse
+	if err := json.NewDecoder(resp.Body).Decode(&ur); err != nil {
+		return nil, fmt.Errorf("retrieve multiple users with user names decode: %w", err)
 	}
 	if resp.StatusCode != http.StatusOK {
-		return &user, &HTTPError{
-			APIName: "user lookup by username",
+		return &ur, &HTTPError{
+			APIName: "users lookup by usernames",
 			Status:  resp.Status,
 			URL:     req.URL.String(),
 		}
 	}
 
-	return &user, nil
+	return &ur, nil
 }
 
-func lookUpUsersByUserNames(ctx context.Context, c *client, names []string, opt ...*UserLookUpOption) (*UsersLookUpByUserNamesResponse, error) {
-	// check names
-	switch {
-	case len(names) == 0:
-		return nil, errors.New("users lookup: names parameter is required")
-	case len(names) > userLookUpMaxIDs:
-		return nil, errors.New("users lookup: names parameter must be less than or equal to 100")
-	default:
-	}
-	lookUpUsersByUserName := userLookUp + "/by?usernames="
-	// join ids to url
-	for i, name := range names {
-		if i+1 < len(names) {
-			lookUpUsersByUserName += fmt.Sprintf("%s,", name)
-		} else {
-			lookUpUsersByUserName += name
-		}
+func retrieveSingleUserWithUserName(ctx context.Context, c *client, userName string, opt ...*RetrieveUserOption) (*UserResponse, error) {
+	if userName == "" {
+		return nil, errors.New("retrieve single user with user name: user name is required")
 	}
+	ep := fmt.Sprintf(retrieveSingleUserWithUserNameURL, userName)
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, lookUpUsersByUserName, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ep, nil)
 	if err != nil {
-		return nil, fmt.Errorf("users lookup by usernames new request with ctx: %w", err)
+		return nil, fmt.Errorf("retrieve single user with user name new request with ctx: %w", err)
 	}
 
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
 
-	var topt UserLookUpOption
+	var ropt RetrieveUserOption
 	switch len(opt) {
 	case 0:
 		// do nothing
 	case 1:
-		topt = *opt[0]
+		ropt = *opt[0]
 	default:
-		return nil, errors.New("users lookup by usernames: only one option is allowed")
+		return nil, errors.New("retrieve single user with user name: only one option is allowed")
 	}
-	topt.addQuery(req)
+	ropt.addQuery(req)
 
 	resp, err := c.client.Do(req)
 	if err != nil {
-		return nil, fmt.Errorf("users lookup by usernames response: %w", err)
+		return nil, fmt.Errorf("retrieve single user with user name response: %w", err)
 	}
 
 	defer resp.Body.Close()
 
-	var users UsersLookUpByUserNamesResponse
-	if err := json.NewDecoder(resp.Body).Decode(&users); err != nil {
-		return nil, fmt.Errorf("users lookup by usernames decode: %w", err)
+	var ur UserResponse
+	if err := json.NewDecoder(resp.Body).Decode(&ur); err != nil {
+		return nil, fmt.Errorf("retrieve single user with user name decode: %w", err)
 	}
 	if resp.StatusCode != http.StatusOK {
-		return &users, &HTTPError{
-			APIName: "users lookup by usernames",
+		return &ur, &HTTPError{
+			APIName: "retrieve single user with user name",
 			Status:  resp.Status,
 			URL:     req.URL.String(),
 		}
 	}
 
-	return &users, nil
+	return &ur, nil
 }
diff --git a/user_option.go b/user_option.go
index ef977c3..6061b52 100644
--- a/user_option.go
+++ b/user_option.go
@@ -6,22 +6,22 @@ import (
 	"strings"
 )
 
-type UserLookUpOption struct {
+type RetrieveUserOption struct {
 	Expansions  []Expansion
 	TweetFields []TweetField
 	UserFields  []UserField
 }
 
-func (t *UserLookUpOption) addQuery(req *http.Request) {
+func (r *RetrieveUserOption) addQuery(req *http.Request) {
 	q := req.URL.Query()
-	if len(t.Expansions) > 0 {
-		q.Add("expansions", strings.Join(expansionsToString(t.Expansions), ","))
+	if len(r.Expansions) > 0 {
+		q.Add("expansions", strings.Join(expansionsToString(r.Expansions), ","))
 	}
-	if len(t.TweetFields) > 0 {
-		q.Add("tweet.fields", strings.Join(tweetFieldsToString(t.TweetFields), ","))
+	if len(r.TweetFields) > 0 {
+		q.Add("tweet.fields", strings.Join(tweetFieldsToString(r.TweetFields), ","))
 	}
-	if len(t.UserFields) > 0 {
-		q.Add("user.fields", strings.Join(userFieldsToString(t.UserFields), ","))
+	if len(r.UserFields) > 0 {
+		q.Add("user.fields", strings.Join(userFieldsToString(r.UserFields), ","))
 	}
 	if len(q) > 0 {
 		req.URL.RawQuery = q.Encode()
diff --git a/sampled_stream.go b/volume_stream.go
similarity index 67%
rename from sampled_stream.go
rename to volume_stream.go
index f4c57e5..5dd5ec1 100644
--- a/sampled_stream.go
+++ b/volume_stream.go
@@ -19,12 +19,12 @@ func stopped(done <-chan struct{}) bool {
 	}
 }
 
-func (s *StreamResponse) Stop() {
+func (s *VolumeStreams) Stop() {
 	close(s.done)
 	s.wg.Wait()
 }
 
-func (s *StreamResponse) retry(req *http.Request) {
+func (s *VolumeStreams) retry(req *http.Request) {
 	defer s.wg.Done()
 	resp, err := s.client.Do(req)
 	if err != nil {
@@ -42,44 +42,44 @@ func (s *StreamResponse) retry(req *http.Request) {
 	}
 	dec := json.NewDecoder(resp.Body)
 	for !stopped(s.done) {
-		var res SampledStreamResponse
-		err := dec.Decode(&res)
+		var v VolumeStreamsResponse
+		err := dec.Decode(&v)
 		if err != nil {
 			if err == io.EOF {
 				break
 			}
 			s.errCh <- err
 		}
-		s.ch <- res
+		s.ch <- v
 	}
 }
 
-func sampledStream(ctx context.Context, c *client, ch chan<- SampledStreamResponse, errCh chan<- error, opt ...*SampledStreamOpts) *StreamResponse {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, sampleStream, nil)
+func volumeStreams(ctx context.Context, c *client, ch chan<- VolumeStreamsResponse, errCh chan<- error, opt ...*VolumeStreamsOption) *VolumeStreams {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, volumeStreamsURL, nil)
 	if err != nil {
 		errCh <- fmt.Errorf("sampled stream new request with ctx: %w", err)
 	}
 	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.bearerToken))
 
-	var sopt SampledStreamOpts
+	var vopt VolumeStreamsOption
 	switch len(opt) {
 	case 0:
 		// do nothing
 	case 1:
-		sopt = *opt[0]
+		vopt = *opt[0]
 	default:
 		errCh <- errors.New("sampled stream: only one option is allowed")
 	}
-	sopt.addQuery(req)
+	vopt.addQuery(req)
 
-	s := &StreamResponse{
+	vs := &VolumeStreams{
 		client: c.client,
 		errCh:  errCh,
 		ch:     ch,
 		done:   make(chan struct{}),
 		wg:     &sync.WaitGroup{},
 	}
-	s.wg.Add(1)
-	go s.retry(req)
-	return s
+	vs.wg.Add(1)
+	go vs.retry(req)
+	return vs
 }


Test patch:
diff --git a/discover_spaces_test.go b/discover_spaces_test.go
index af9e245..978330e 100644
--- a/discover_spaces_test.go
+++ b/discover_spaces_test.go
@@ -11,7 +11,7 @@ import (
 	"github.com/sivchari/gotwtr"
 )
 
-func Test_discoverSpacesByUserIDs(t *testing.T) {
+func Test_discoverSpaces(t *testing.T) {
 	t.Parallel()
 	type args struct {
 		ctx    context.Context
@@ -22,7 +22,7 @@ func Test_discoverSpacesByUserIDs(t *testing.T) {
 	tests := []struct {
 		name    string
 		args    args
-		want    *gotwtr.DiscoverSpacesByUserIDsResponse
+		want    *gotwtr.DiscoverSpacesResponse
 		wantErr bool
 	}{
 		{
@@ -49,7 +49,7 @@ func Test_discoverSpacesByUserIDs(t *testing.T) {
 				ids: []string{"2244994945,6253282"},
 				opt: []*gotwtr.DiscoverSpacesOption{},
 			},
-			want: &gotwtr.DiscoverSpacesByUserIDsResponse{
+			want: &gotwtr.DiscoverSpacesResponse{
 				Spaces: []*gotwtr.Space{
 					{
 						ID:    "1DXxyRYNejbKM",
@@ -68,13 +68,13 @@ func Test_discoverSpacesByUserIDs(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			c := gotwtr.New("test-key", gotwtr.WithHTTPClient(tt.args.client))
-			got, err := c.DiscoverSpacesByUserIDs(tt.args.ctx, tt.args.ids, tt.args.opt...)
+			got, err := c.DiscoverSpaces(tt.args.ctx, tt.args.ids, tt.args.opt...)
 			if (err != nil) != tt.wantErr {
-				t.Errorf("client.DiscoverSpacesByUserIDs() error = %v, wantErr %v", err, tt.wantErr)
+				t.Errorf("client.DiscoverSpaces() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
 			if diff := cmp.Diff(tt.want, got); diff != "" {
-				t.Errorf("client.DiscoverSpacesByUserIDs() mismatch (-want +got):\n%s", diff)
+				t.Errorf("client.DiscoverSpaces() mismatch (-want +got):\n%s", diff)
 				return
 			}
 		})
diff --git a/follows_test.go b/follow_test.go
similarity index 99%
rename from follows_test.go
rename to follow_test.go
index 1f75391..a5afec2 100644
--- a/follows_test.go
+++ b/follow_test.go
@@ -720,7 +720,7 @@ func Test_followers(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			c := gotwtr.New("test-key", gotwtr.WithHTTPClient(tt.args.client))
-			got, err := c.LookUpFollowers(tt.args.ctx, tt.args.id, tt.args.opt...)
+			got, err := c.Followers(tt.args.ctx, tt.args.id, tt.args.opt...)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("client.Followers() index = %v error = %v, wantErr %v", i, err, tt.wantErr)
 				return
@@ -1442,7 +1442,7 @@ func Test_following(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			c := gotwtr.New("test-key", gotwtr.WithHTTPClient(tt.args.client))
-			got, err := c.LookUpFollowing(tt.args.ctx, tt.args.id, tt.args.opt...)
+			got, err := c.Following(tt.args.ctx, tt.args.id, tt.args.opt...)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("client.Following() index = %v error = %v, wantErr %v", i, err, tt.wantErr)
 				return
diff --git a/likes_lookup_test.go b/likes_lookup_test.go
index c0616ab..9e9add4 100644
--- a/likes_lookup_test.go
+++ b/likes_lookup_test.go
@@ -11,17 +11,17 @@ import (
 	"github.com/sivchari/gotwtr"
 )
 
-func Test_lookUpUsersWhoLiked(t *testing.T) {
+func Test_usersLikingTweet(t *testing.T) {
 	t.Parallel()
 	type args struct {
 		ctx    context.Context
 		client *http.Client
-		opt    []*gotwtr.LookUpUsersWhoLikedOpts
+		opt    []*gotwtr.UsersLikingTweetOption
 	}
 	tests := []struct {
 		name    string
 		args    args
-		want    *gotwtr.LookUpUsersWhoLikedResponse
+		want    *gotwtr.UsersLikingTweetResponse
 		wantErr bool
 	}{
 		{
@@ -54,7 +54,7 @@ func Test_lookUpUsersWhoLiked(t *testing.T) {
 					}
 				}),
 			},
-			want: &gotwtr.LookUpUsersWhoLikedResponse{
+			want: &gotwtr.UsersLikingTweetResponse{
 				Users: []*gotwtr.LookUpUsersWhoLiked{
 					{
 						ID:       "1065249714214457345",
@@ -143,7 +143,7 @@ func Test_lookUpUsersWhoLiked(t *testing.T) {
 						Body:       io.NopCloser(strings.NewReader(body)),
 					}
 				}),
-				opt: []*gotwtr.LookUpUsersWhoLikedOpts{
+				opt: []*gotwtr.UsersLikingTweetOption{
 					{
 						Expansions:  []gotwtr.Expansion{gotwtr.ExpansionPinnedTweetID},
 						UserFields:  []gotwtr.UserField{gotwtr.UserFieldCreatedAt},
@@ -151,7 +151,7 @@ func Test_lookUpUsersWhoLiked(t *testing.T) {
 					},
 				},
 			},
-			want: &gotwtr.LookUpUsersWhoLikedResponse{
+			want: &gotwtr.UsersLikingTweetResponse{
 				Users: []*gotwtr.LookUpUsersWhoLiked{
 					{
 						ID:            "1065249714214457345",
@@ -218,13 +218,13 @@ func Test_lookUpUsersWhoLiked(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			c := gotwtr.New("test-key", gotwtr.WithHTTPClient(tt.args.client))
-			got, err := c.LookUpUsersWhoLiked(tt.args.ctx, "tweet_id", tt.args.opt...)
+			got, err := c.UsersLikingTweet(tt.args.ctx, "tweet_id", tt.args.opt...)
 			if (err != nil) != tt.wantErr {
-				t.Errorf("client.LookUpUsersWhoLiked() error = %v, wantErr %v", err, tt.wantErr)
+				t.Errorf("client.UsersLikingTweet() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
 			if diff := cmp.Diff(tt.want, got); diff != "" {
-				t.Errorf("client.LookUpUsersWhoLiked() mismatch (-want +got):\n%s", diff)
+				t.Errorf("client.UsersLikingTweet() mismatch (-want +got):\n%s", diff)
 				return
 			}
 		})
diff --git a/list_follows_test.go b/list_follows_test.go
index 415a28d..f276b13 100644
--- a/list_follows_test.go
+++ b/list_follows_test.go
@@ -11,18 +11,18 @@ import (
 	"github.com/sivchari/gotwtr"
 )
 
-func Test_lookUpListFollowersByID(t *testing.T) {
+func Test_lookUpListFollowers(t *testing.T) {
 	t.Parallel()
 	type args struct {
 		ctx    context.Context
 		client *http.Client
 		id     string
-		opt    []*gotwtr.ListLookUpOption
+		opt    []*gotwtr.ListFollowersOption
 	}
 	tests := []struct {
 		name    string
 		args    args
-		want    *gotwtr.ListFollowersLookUpByIDResponse
+		want    *gotwtr.ListFollowersResponse
 		wantErr bool
 	}{
 		{
@@ -69,9 +69,9 @@ func Test_lookUpListFollowersByID(t *testing.T) {
 					}
 				}),
 				id:  "84839422",
-				opt: []*gotwtr.ListLookUpOption{},
+				opt: []*gotwtr.ListFollowersOption{},
 			},
-			want: &gotwtr.ListFollowersLookUpByIDResponse{
+			want: &gotwtr.ListFollowersResponse{
 				Users: []*gotwtr.User{
 					{
 						ID:       "1324848235714736129",
@@ -173,7 +173,7 @@ func Test_lookUpListFollowersByID(t *testing.T) {
 					}
 				}),
 				id: "84839422",
-				opt: []*gotwtr.ListLookUpOption{
+				opt: []*gotwtr.ListFollowersOption{
 					{
 						Expansions: []gotwtr.Expansion{
 							gotwtr.ExpansionPinnedTweetID,
@@ -187,7 +187,7 @@ func Test_lookUpListFollowersByID(t *testing.T) {
 					},
 				},
 			},
-			want: &gotwtr.ListFollowersLookUpByIDResponse{
+			want: &gotwtr.ListFollowersResponse{
 				Users: []*gotwtr.User{
 					{
 						UserName:  "alanbenlee",
@@ -270,9 +270,9 @@ func Test_lookUpListFollowersByID(t *testing.T) {
 					}
 				}),
 				id:  "111111111111111111111111111111111111",
-				opt: []*gotwtr.ListLookUpOption{},
+				opt: []*gotwtr.ListFollowersOption{},
 			},
-			want: &gotwtr.ListFollowersLookUpByIDResponse{
+			want: &gotwtr.ListFollowersResponse{
 				Users: nil,
 				Errors: []*gotwtr.APIResponseError{
 					{
@@ -295,7 +295,7 @@ func Test_lookUpListFollowersByID(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			c := gotwtr.New("test-key", gotwtr.WithHTTPClient(tt.args.client))
-			got, err := c.LookUpListFollowersByID(tt.args.ctx, tt.args.id, tt.args.opt...)
+			got, err := c.LookUpListFollowers(tt.args.ctx, tt.args.id, tt.args.opt...)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("client.LookUpListFollowersByID() index = %v error = %v, wantErr %v", i, err, tt.wantErr)
 				return
@@ -308,18 +308,18 @@ func Test_lookUpListFollowersByID(t *testing.T) {
 	}
 }
 
-func Test_lookUpListsUserFollowingByID(t *testing.T) {
+func Test_lookUpAllListsUserFollows(t *testing.T) {
 	t.Parallel()
 	type args struct {
 		ctx    context.Context
 		client *http.Client
 		id     string
-		opt    []*gotwtr.ListLookUpOption
+		opt    []*gotwtr.ListFollowsOption
 	}
 	tests := []struct {
 		name    string
 		args    args
-		want    *gotwtr.ListsUserFollowingLookUpByIDResponse
+		want    *gotwtr.AllListsUserFollowsResponse
 		wantErr bool
 	}{
 		{
@@ -344,9 +344,9 @@ func Test_lookUpListsUserFollowingByID(t *testing.T) {
 					}
 				}),
 				id:  "2244994945",
-				opt: []*gotwtr.ListLookUpOption{},
+				opt: []*gotwtr.ListFollowsOption{},
 			},
-			want: &gotwtr.ListsUserFollowingLookUpByIDResponse{
+			want: &gotwtr.AllListsUserFollowsResponse{
 				Lists: []*gotwtr.List{
 					{
 						ID:   "1630685563471",
@@ -393,7 +393,7 @@ func Test_lookUpListsUserFollowingByID(t *testing.T) {
 					}
 				}),
 				id: "2244994945",
-				opt: []*gotwtr.ListLookUpOption{
+				opt: []*gotwtr.ListFollowsOption{
 					{
 						Expansions: []gotwtr.Expansion{
 							gotwtr.ExpansionOwnerID,
@@ -407,7 +407,7 @@ func Test_lookUpListsUserFollowingByID(t *testing.T) {
 					},
 				},
 			},
-			want: &gotwtr.ListsUserFollowingLookUpByIDResponse{
+			want: &gotwtr.AllListsUserFollowsResponse{
 				Lists: []*gotwtr.List{
 					{
 						FollowerCount: 123,
@@ -458,9 +458,9 @@ func Test_lookUpListsUserFollowingByID(t *testing.T) {
 					}
 				}),
 				id:  "111111111111111111111111111111111111111111111111111111",
-				opt: []*gotwtr.ListLookUpOption{},
+				opt: []*gotwtr.ListFollowsOption{},
 			},
-			want: &gotwtr.ListsUserFollowingLookUpByIDResponse{
+			want: &gotwtr.AllListsUserFollowsResponse{
 				Lists: nil,
 				Errors: []*gotwtr.APIResponseError{
 					{
@@ -477,18 +477,18 @@ func Test_lookUpListsUserFollowingByID(t *testing.T) {
 			wantErr: true,
 		},
 	}
-	for i, tt := range tests {
+	for _, tt := range tests {
 		tt := tt
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			c := gotwtr.New("test-key", gotwtr.WithHTTPClient(tt.args.client))
-			got, err := c.LookUpListsUserFollowingByID(tt.args.ctx, tt.args.id, tt.args.opt...)
+			got, err := c.LookUpAllListsUserFollows(tt.args.ctx, tt.args.id, tt.args.opt...)
 			if (err != nil) != tt.wantErr {
-				t.Errorf("client.LookUpListsUserFollowingByID() index = %v error = %v, wantErr %v", i, err, tt.wantErr)
+				t.Errorf("client.LookUpAllListsUserFollows() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
 			if diff := cmp.Diff(tt.want, got); diff != "" {
-				t.Errorf("client.LookUpListsUserFollowingByID() index = %v mismatch (-want +got):\n%s", i, diff)
+				t.Errorf("client.LookUpAllListsUserFollows() mismatch (-want +got):\n%s", diff)
 				return
 			}
 		})
diff --git a/list_lookup_test.go b/list_lookup_test.go
index 45e76f6..8f3239f 100644
--- a/list_lookup_test.go
+++ b/list_lookup_test.go
@@ -11,18 +11,18 @@ import (
 	"github.com/sivchari/gotwtr"
 )
 
-func Test_lookUpOwnedListByID(t *testing.T) {
+func Test_lookUpAllListsOwned(t *testing.T) {
 	t.Parallel()
 	type args struct {
 		ctx    context.Context
 		client *http.Client
 		id     string
-		opt    []*gotwtr.ListLookUpOption
+		opt    []*gotwtr.AllListsOwnedOption
 	}
 	tests := []struct {
 		name    string
 		args    args
-		want    *gotwtr.OwnedListsLookUpByIDResponse
+		want    *gotwtr.AllListsOwnedResponse
 		wantErr bool
 	}{
 		{
@@ -47,9 +47,9 @@ func Test_lookUpOwnedListByID(t *testing.T) {
 					}
 				}),
 				id:  "2244994945",
-				opt: []*gotwtr.ListLookUpOption{},
+				opt: []*gotwtr.AllListsOwnedOption{},
 			},
-			want: &gotwtr.OwnedListsLookUpByIDResponse{
+			want: &gotwtr.AllListsOwnedResponse{
 				Lists: []*gotwtr.List{
 					{
 						ID:   "1451305624956858369",
@@ -98,7 +98,7 @@ func Test_lookUpOwnedListByID(t *testing.T) {
 					}
 				}),
 				id: "2244994945",
-				opt: []*gotwtr.ListLookUpOption{
+				opt: []*gotwtr.AllListsOwnedOption{
 					{
 						UserFields: []gotwtr.UserField{
 							gotwtr.UserFieldUserName,
@@ -109,7 +109,7 @@ func Test_lookUpOwnedListByID(t *testing.T) {
 					},
 				},
 			},
-			want: &gotwtr.OwnedListsLookUpByIDResponse{
+			want: &gotwtr.AllListsOwnedResponse{
 				Lists: []*gotwtr.List{
 					{
 						FollowerCount: 0,
@@ -161,9 +161,9 @@ func Test_lookUpOwnedListByID(t *testing.T) {
 					}
 				}),
 				id:  "2222222222222222222222222222",
-				opt: []*gotwtr.ListLookUpOption{},
+				opt: []*gotwtr.AllListsOwnedOption{},
 			},
-			want: &gotwtr.OwnedListsLookUpByIDResponse{
+			want: &gotwtr.AllListsOwnedResponse{
 				Lists: nil,
 				Errors: []*gotwtr.APIResponseError{
 					{
@@ -186,7 +186,7 @@ func Test_lookUpOwnedListByID(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			c := gotwtr.New("test-key", gotwtr.WithHTTPClient(tt.args.client))
-			got, err := c.LookUpOwnedListsByID(tt.args.ctx, tt.args.id, tt.args.opt...)
+			got, err := c.LookUpAllListsOwned(tt.args.ctx, tt.args.id, tt.args.opt...)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("client.LookUpOwnedListsByID() index = %v error = %v, wantErr %v", i, err, tt.wantErr)
 				return
@@ -199,18 +199,18 @@ func Test_lookUpOwnedListByID(t *testing.T) {
 	}
 }
 
-func Test_lookUpListByID(t *testing.T) {
+func Test_lookUpList(t *testing.T) {
 	t.Parallel()
 	type args struct {
 		ctx    context.Context
 		client *http.Client
 		id     string
-		opt    []*gotwtr.ListLookUpOption
+		opt    []*gotwtr.LookUpListOption
 	}
 	tests := []struct {
 		name    string
 		args    args
-		want    *gotwtr.ListLookUpByIDResponse
+		want    *gotwtr.ListResponse
 		wantErr bool
 	}{
 		{
@@ -230,9 +230,9 @@ func Test_lookUpListByID(t *testing.T) {
 					}
 				}),
 				id:  "84839422",
-				opt: []*gotwtr.ListLookUpOption{},
+				opt: []*gotwtr.LookUpListOption{},
 			},
-			want: &gotwtr.ListLookUpByIDResponse{
+			want: &gotwtr.ListResponse{
 				List: &gotwtr.List{
 					ID:   "84839422",
 					Name: "Official Twitter Accounts",
@@ -268,7 +268,7 @@ func Test_lookUpListByID(t *testing.T) {
 					}
 				}),
 				id: "84839422",
-				opt: []*gotwtr.ListLookUpOption{
+				opt: []*gotwtr.LookUpListOption{
 					{
 						UserFields: []gotwtr.UserField{
 							gotwtr.UserFieldID,
@@ -278,7 +278,7 @@ func Test_lookUpListByID(t *testing.T) {
 					},
 				},
 			},
-			want: &gotwtr.ListLookUpByIDResponse{
+			want: &gotwtr.ListResponse{
 				List: &gotwtr.List{
 					FollowerCount: 906,
 					ID:            "84839422",
@@ -323,9 +323,9 @@ func Test_lookUpListByID(t *testing.T) {
 					}
 				}),
 				id:  "111111111111111111111111",
-				opt: []*gotwtr.ListLookUpOption{},
+				opt: []*gotwtr.LookUpListOption{},
 			},
-			want: &gotwtr.ListLookUpByIDResponse{
+			want: &gotwtr.ListResponse{
 				List: nil,
 				Errors: []*gotwtr.APIResponseError{
 					{
@@ -347,7 +347,7 @@ func Test_lookUpListByID(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			c := gotwtr.New("test-key", gotwtr.WithHTTPClient(tt.args.client))
-			got, err := c.LookUpListByID(tt.args.ctx, tt.args.id, tt.args.opt...)
+			got, err := c.LookUpList(tt.args.ctx, tt.args.id, tt.args.opt...)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("client.LookUpListByID() index = %v error = %v, wantErr %v", i, err, tt.wantErr)
 				return
diff --git a/list_tweets_lookup_test.go b/list_tweets_lookup_test.go
index 90eb37a..177e4a1 100644
--- a/list_tweets_lookup_test.go
+++ b/list_tweets_lookup_test.go
@@ -11,18 +11,18 @@ import (
 	"github.com/sivchari/gotwtr"
 )
 
-func Test_lookUpListsTweetsByID(t *testing.T) {
+func Test_lookUpListTweets(t *testing.T) {
 	t.Parallel()
 	type args struct {
 		ctx    context.Context
 		client *http.Client
 		id     string
-		opt    []*gotwtr.ListLookUpOption
+		opt    []*gotwtr.ListTweetsOption
 	}
 	tests := []struct {
 		name    string
 		args    args
-		want    *gotwtr.ListsTweetsLookUpByIDResponse
+		want    *gotwtr.ListTweetsResponse
 		wantErr bool
 	}{
 		{
@@ -47,9 +47,9 @@ func Test_lookUpListsTweetsByID(t *testing.T) {
 					}
 				}),
 				id:  "2244994945",
-				opt: []*gotwtr.ListLookUpOption{},
+				opt: []*gotwtr.ListTweetsOption{},
 			},
-			want: &gotwtr.ListsTweetsLookUpByIDResponse{
+			want: &gotwtr.ListTweetsResponse{
 				Tweets: []*gotwtr.Tweet{
 					{
 						ID:   "1067094924124872705",
@@ -98,7 +98,7 @@ func Test_lookUpListsTweetsByID(t *testing.T) {
 					}
 				}),
 				id: "84839422",
-				opt: []*gotwtr.ListLookUpOption{
+				opt: []*gotwtr.ListTweetsOption{
 					{
 						UserFields: []gotwtr.UserField{
 							gotwtr.UserFieldVerified,
@@ -109,7 +109,7 @@ func Test_lookUpListsTweetsByID(t *testing.T) {
 					},
 				},
 			},
-			want: &gotwtr.ListsTweetsLookUpByIDResponse{
+			want: &gotwtr.ListTweetsResponse{
 				Tweets: []*gotwtr.Tweet{
 					{
 						AuthorID:  "2244994945",
@@ -161,9 +161,9 @@ func Test_lookUpListsTweetsByID(t *testing.T) {
 					}
 				}),
 				id:  "111111111111111111111111",
-				opt: []*gotwtr.ListLookUpOption{},
+				opt: []*gotwtr.ListTweetsOption{},
 			},
-			want: &gotwtr.ListsTweetsLookUpByIDResponse{
+			want: &gotwtr.ListTweetsResponse{
 				Tweets: nil,
 				Errors: []*gotwtr.APIResponseError{
 					{
@@ -186,7 +186,7 @@ func Test_lookUpListsTweetsByID(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			c := gotwtr.New("test-key", gotwtr.WithHTTPClient(tt.args.client))
-			got, err := c.LookUpListsTweetsByID(tt.args.ctx, tt.args.id, tt.args.opt...)
+			got, err := c.LookUpListTweets(tt.args.ctx, tt.args.id, tt.args.opt...)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("client.LookUpListsTweetsByID() index = %v error = %v, wantErr %v", i, err, tt.wantErr)
 				return
diff --git a/retweets_test.go b/retweet_test.go
similarity index 97%
rename from retweets_test.go
rename to retweet_test.go
index 6fbe77a..a274145 100644
--- a/retweets_test.go
+++ b/retweet_test.go
@@ -17,12 +17,12 @@ func Test_retweetsLookup(t *testing.T) {
 		ctx    context.Context
 		client *http.Client
 		id     string
-		opt    []*gotwtr.RetweetsLookupOpts
+		opt    []*gotwtr.RetweetsLookupOption
 	}
 	tests := []struct {
 		name    string
 		args    args
-		want    *gotwtr.RetweetsLookupResponse
+		want    *gotwtr.RetweetsResponse
 		wantErr bool
 	}{
 		{
@@ -98,7 +98,7 @@ func Test_retweetsLookup(t *testing.T) {
 				}),
 				id: "1354143047324299264",
 			},
-			want: &gotwtr.RetweetsLookupResponse{
+			want: &gotwtr.RetweetsResponse{
 				Users: []*gotwtr.User{
 					{
 						ID:            "1065249714214457345",
@@ -186,7 +186,7 @@ func Test_retweetsLookup(t *testing.T) {
 				}),
 				id: "11111111111111111",
 			},
-			want: &gotwtr.RetweetsLookupResponse{
+			want: &gotwtr.RetweetsResponse{
 				Users: nil,
 				Errors: []*gotwtr.APIResponseError{
 					{
diff --git a/search_tweets_test.go b/search_tweet_test.go
similarity index 96%
rename from search_tweets_test.go
rename to search_tweet_test.go
index 204dda9..8bf84fa 100644
--- a/search_tweets_test.go
+++ b/search_tweet_test.go
@@ -17,12 +17,12 @@ func Test_searchRecentTweets(t *testing.T) {
 		ctx    context.Context
 		client *http.Client
 		query  string
-		opt    []*gotwtr.TweetSearchOption
+		opt    []*gotwtr.SearchTweetsOption
 	}
 	tests := []struct {
 		name    string
 		args    args
-		want    *gotwtr.TweetSearchResponse
+		want    *gotwtr.SearchTweetsResponse
 		wantErr bool
 	}{
 		{
@@ -86,9 +86,9 @@ func Test_searchRecentTweets(t *testing.T) {
 					}
 				}),
 				query: "nyc",
-				opt:   []*gotwtr.TweetSearchOption{},
+				opt:   []*gotwtr.SearchTweetsOption{},
 			},
-			want: &gotwtr.TweetSearchResponse{
+			want: &gotwtr.SearchTweetsResponse{
 				Tweets: []*gotwtr.Tweet{
 					{
 						ID:   "1444834989024202755",
@@ -131,7 +131,7 @@ func Test_searchRecentTweets(t *testing.T) {
 						Text: "RT @elhammohamud: girlies be like nyc is not ready for us like nyc has never seen 10 harry styles fans in head to toe shein walking around…",
 					},
 				},
-				Meta: &gotwtr.TweetSearchMeta{
+				Meta: &gotwtr.SearchTweetsMeta{
 					NewestID:    "1444834989024202755",
 					OldestID:    "1444834974646116359",
 					ResultCount: 10,
diff --git a/space_lookup_test.go b/space_lookup_test.go
index 354e96c..4924b1e 100644
--- a/space_lookup_test.go
+++ b/space_lookup_test.go
@@ -18,12 +18,12 @@ func Test_lookUpSpaces(t *testing.T) {
 		ctx    context.Context
 		client *http.Client
 		ids    []string
-		opt    []*gotwtr.SpaceLookUpOption
+		opt    []*gotwtr.SpaceOption
 	}
 	tests := []struct {
 		name    string
 		args    args
-		want    *gotwtr.SpaceLookUpResponse
+		want    *gotwtr.SpacesResponse
 		wantErr bool
 	}{
 		{
@@ -52,9 +52,9 @@ func Test_lookUpSpaces(t *testing.T) {
 					"12345",
 					"67890",
 				},
-				opt: []*gotwtr.SpaceLookUpOption{},
+				opt: []*gotwtr.SpaceOption{},
 			},
-			want: &gotwtr.SpaceLookUpResponse{
+			want: &gotwtr.SpacesResponse{
 				Spaces: []*gotwtr.Space{
 					{
 						ID:    "12345",
@@ -106,9 +106,9 @@ func Test_lookUpSpaces(t *testing.T) {
 					"1234567890",
 					"0987654321",
 				},
-				opt: []*gotwtr.SpaceLookUpOption{},
+				opt: []*gotwtr.SpaceOption{},
 			},
-			want: &gotwtr.SpaceLookUpResponse{
+			want: &gotwtr.SpacesResponse{
 				Errors: []*gotwtr.APIResponseError{
 					{
 						Parameters: gotwtr.Parameter{
@@ -148,18 +148,18 @@ func Test_lookUpSpaces(t *testing.T) {
 	}
 }
 
-func Test_lookUpSpaceByID(t *testing.T) {
+func Test_lookUpSpace(t *testing.T) {
 	t.Parallel()
 	type args struct {
 		ctx    context.Context
 		client *http.Client
 		id     string
-		opt    []*gotwtr.SpaceLookUpOption
+		opt    []*gotwtr.SpaceOption
 	}
 	tests := []struct {
 		name    string
 		args    args
-		want    *gotwtr.SpaceLookUpByIDResponse
+		want    *gotwtr.SpaceResponse
 		wantErr bool
 	}{
 		{
@@ -179,9 +179,9 @@ func Test_lookUpSpaceByID(t *testing.T) {
 					}
 				}),
 				id:  "12345",
-				opt: []*gotwtr.SpaceLookUpOption{},
+				opt: []*gotwtr.SpaceOption{},
 			},
-			want: &gotwtr.SpaceLookUpByIDResponse{
+			want: &gotwtr.SpaceResponse{
 				Space: &gotwtr.Space{
 					ID:    "12345",
 					State: "ended",
@@ -216,9 +216,9 @@ func Test_lookUpSpaceByID(t *testing.T) {
 					}
 				}),
 				id:  "111111111111111",
-				opt: []*gotwtr.SpaceLookUpOption{},
+				opt: []*gotwtr.SpaceOption{},
 			},
-			want: &gotwtr.SpaceLookUpByIDResponse{
+			want: &gotwtr.SpaceResponse{
 				Errors: []*gotwtr.APIResponseError{
 					{
 						Parameters: gotwtr.Parameter{
@@ -239,31 +239,31 @@ func Test_lookUpSpaceByID(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			c := gotwtr.New("test-key", gotwtr.WithHTTPClient(tt.args.client))
-			got, err := c.LookUpSpaceByID(tt.args.ctx, tt.args.id, tt.args.opt...)
+			got, err := c.LookUpSpace(tt.args.ctx, tt.args.id, tt.args.opt...)
 			if (err != nil) != tt.wantErr {
-				t.Errorf("client.LookUpSpaceByID() error = %v, wantErr %v", err, tt.wantErr)
+				t.Errorf("client.LookUpSpace() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
 			if diff := cmp.Diff(got, tt.want); diff != "" {
-				t.Errorf("client.LookUpSpaceByID() diff = %v", diff)
+				t.Errorf("client.LookUpSpace() diff = %v", diff)
 				return
 			}
 		})
 	}
 }
 
-func Test_lookUpUsersWhoPurchasedSpaceTicket(t *testing.T) {
+func Test_usersPurchasedSpaceTicket(t *testing.T) {
 	t.Parallel()
 	type args struct {
 		ctx    context.Context
 		client *http.Client
 		id     string
-		opt    []*gotwtr.LookUpUsersWhoPurchasedSpaceTicketOption
+		opt    []*gotwtr.UsersPurchasedSpaceTicketOption
 	}
 	tests := []struct {
 		name    string
 		args    args
-		want    *gotwtr.LookUpUsersWhoPurchasedSpaceTicketResponse
+		want    *gotwtr.UsersPurchasedSpaceTicketResponse
 		wantErr bool
 	}{
 		{
@@ -291,9 +291,9 @@ func Test_lookUpUsersWhoPurchasedSpaceTicket(t *testing.T) {
 					}
 				}),
 				id:  "1DXxyRYNejbKM",
-				opt: []*gotwtr.LookUpUsersWhoPurchasedSpaceTicketOption{},
+				opt: []*gotwtr.UsersPurchasedSpaceTicketOption{},
 			},
-			want: &gotwtr.LookUpUsersWhoPurchasedSpaceTicketResponse{
+			want: &gotwtr.UsersPurchasedSpaceTicketResponse{
 				Users: []*gotwtr.User{
 					{
 						ID:       "2244994945",
@@ -352,7 +352,7 @@ func Test_lookUpUsersWhoPurchasedSpaceTicket(t *testing.T) {
 					}
 				}),
 				id: "1DXxyRYNejbKM",
-				opt: []*gotwtr.LookUpUsersWhoPurchasedSpaceTicketOption{
+				opt: []*gotwtr.UsersPurchasedSpaceTicketOption{
 					{
 						Expansions: []gotwtr.Expansion{
 							gotwtr.ExpansionPinnedTweetID,
@@ -366,7 +366,7 @@ func Test_lookUpUsersWhoPurchasedSpaceTicket(t *testing.T) {
 					},
 				},
 			},
-			want: &gotwtr.LookUpUsersWhoPurchasedSpaceTicketResponse{
+			want: &gotwtr.UsersPurchasedSpaceTicketResponse{
 				Users: []*gotwtr.User{
 					{
 						ID:            "2244994945",
@@ -406,13 +406,13 @@ func Test_lookUpUsersWhoPurchasedSpaceTicket(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			c := gotwtr.New("test-key", gotwtr.WithHTTPClient(tt.args.client))
-			got, err := c.LookUpUsersWhoPurchasedSpaceTicket(tt.args.ctx, tt.args.id, tt.args.opt...)
+			got, err := c.UsersPurchasedSpaceTicket(tt.args.ctx, tt.args.id, tt.args.opt...)
 			if (err != nil) != tt.wantErr {
-				t.Errorf("client.LookUpUsersWhoPurchasedSpaceTicket() error = %v, wantErr %v", err, tt.wantErr)
+				t.Errorf("client.UsersPurchasedSpaceTicket() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
 			if diff := cmp.Diff(tt.want, got); diff != "" {
-				t.Errorf("client.LookUpUsersWhoPurchasedSpaceTicket() mismatch (-want +got):\n%s", diff)
+				t.Errorf("client.UsersPurchasedSpaceTicket() mismatch (-want +got):\n%s", diff)
 				return
 			}
 		})
diff --git a/tweet_lookup_test.go b/tweet_lookup_test.go
index 422569d..0d8f4b1 100644
--- a/tweet_lookup_test.go
+++ b/tweet_lookup_test.go
@@ -16,18 +16,18 @@ import (
 // Twitter look up API's response may be changed. Need to check the response.
 // The sample response now definitely exists.
 // A few might have been added.
-func Test_lookUp(t *testing.T) {
+func Test_retriveMultipleTweets(t *testing.T) {
 	t.Parallel()
 	type args struct {
 		ctx    context.Context
 		client *http.Client
 		ids    []string
-		opt    []*gotwtr.TweetLookUpOption
+		opt    []*gotwtr.RetriveTweetOption
 	}
 	tests := []struct {
 		name    string
 		args    args
-		want    *gotwtr.TweetLookUpResponse
+		want    *gotwtr.TweetsResponse
 		wantErr bool
 	}{
 		{
@@ -49,9 +49,9 @@ func Test_lookUp(t *testing.T) {
 					}
 				}),
 				ids: []string{"123456789"},
-				opt: []*gotwtr.TweetLookUpOption{},
+				opt: []*gotwtr.RetriveTweetOption{},
 			},
-			want: &gotwtr.TweetLookUpResponse{
+			want: &gotwtr.TweetsResponse{
 				Tweets: []*gotwtr.Tweet{
 					{
 						ID:   "123456789",
@@ -94,7 +94,7 @@ func Test_lookUp(t *testing.T) {
 					}
 				}),
 				ids: []string{"123456789"},
-				opt: []*gotwtr.TweetLookUpOption{
+				opt: []*gotwtr.RetriveTweetOption{
 					{
 						Expansions: []gotwtr.Expansion{gotwtr.ExpansionAuthorID},
 						TweetFields: []gotwtr.TweetField{
@@ -107,7 +107,7 @@ func Test_lookUp(t *testing.T) {
 					},
 				},
 			},
-			want: &gotwtr.TweetLookUpResponse{
+			want: &gotwtr.TweetsResponse{
 				Tweets: []*gotwtr.Tweet{
 					{
 						AuthorID:  "11111111",
@@ -153,9 +153,9 @@ func Test_lookUp(t *testing.T) {
 					}
 				}),
 				ids: []string{"123456789", "987654321"},
-				opt: []*gotwtr.TweetLookUpOption{},
+				opt: []*gotwtr.RetriveTweetOption{},
 			},
-			want: &gotwtr.TweetLookUpResponse{
+			want: &gotwtr.TweetsResponse{
 				Tweets: []*gotwtr.Tweet{
 					{
 						ID:   "123456789",
@@ -214,7 +214,7 @@ func Test_lookUp(t *testing.T) {
 					}
 				}),
 				ids: []string{"123456789", "987654321"},
-				opt: []*gotwtr.TweetLookUpOption{
+				opt: []*gotwtr.RetriveTweetOption{
 					{
 						Expansions: []gotwtr.Expansion{gotwtr.ExpansionAuthorID},
 						TweetFields: []gotwtr.TweetField{
@@ -227,7 +227,7 @@ func Test_lookUp(t *testing.T) {
 					},
 				},
 			},
-			want: &gotwtr.TweetLookUpResponse{
+			want: &gotwtr.TweetsResponse{
 				Tweets: []*gotwtr.Tweet{
 					{
 						AuthorID:  "11111111",
@@ -290,9 +290,9 @@ func Test_lookUp(t *testing.T) {
 					}
 				}),
 				ids: []string{"20", "1276230436478386177"},
-				opt: []*gotwtr.TweetLookUpOption{},
+				opt: []*gotwtr.RetriveTweetOption{},
 			},
-			want: &gotwtr.TweetLookUpResponse{
+			want: &gotwtr.TweetsResponse{
 				Tweets: []*gotwtr.Tweet{
 					{
 						ID:   "20",
@@ -339,9 +339,9 @@ func Test_lookUp(t *testing.T) {
 					}
 				}),
 				ids: []string{"123456789"},
-				opt: []*gotwtr.TweetLookUpOption{},
+				opt: []*gotwtr.RetriveTweetOption{},
 			},
-			want: &gotwtr.TweetLookUpResponse{
+			want: &gotwtr.TweetsResponse{
 				Tweets: nil,
 				Errors: []*gotwtr.APIResponseError{
 					{
@@ -363,13 +363,13 @@ func Test_lookUp(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			c := gotwtr.New("test-key", gotwtr.WithHTTPClient(tt.args.client))
-			got, err := c.LookUpTweets(tt.args.ctx, tt.args.ids, tt.args.opt...)
+			got, err := c.RetriveMultipleTweets(tt.args.ctx, tt.args.ids, tt.args.opt...)
 			if (err != nil) != tt.wantErr {
-				t.Errorf("client.LookUpTweets() error = %v, wantErr %v", err, tt.wantErr)
+				t.Errorf("client.RetriveMultipleTweets() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
 			if diff := cmp.Diff(tt.want, got); diff != "" {
-				t.Errorf("client.LookUpTweets() mismatch (-want +got):\n%s", diff)
+				t.Errorf("client.RetriveMultipleTweets() mismatch (-want +got):\n%s", diff)
 				return
 			}
 		})
@@ -382,12 +382,12 @@ func Test_lookUpByID(t *testing.T) {
 		ctx    context.Context
 		client *http.Client
 		id     string
-		opt    []*gotwtr.TweetLookUpOption
+		opt    []*gotwtr.RetriveTweetOption
 	}
 	tests := []struct {
 		name    string
 		args    args
-		want    *gotwtr.TweetLookUpByIDResponse
+		want    *gotwtr.TweetResponse
 		wantErr bool
 	}{
 		{
@@ -407,9 +407,9 @@ func Test_lookUpByID(t *testing.T) {
 					}
 				}),
 				id:  "20",
-				opt: []*gotwtr.TweetLookUpOption{},
+				opt: []*gotwtr.RetriveTweetOption{},
 			},
-			want: &gotwtr.TweetLookUpByIDResponse{
+			want: &gotwtr.TweetResponse{
 				Tweet: &gotwtr.Tweet{
 					ID:   "20",
 					Text: "just setting up my twttr",
@@ -489,7 +489,7 @@ func Test_lookUpByID(t *testing.T) {
 					}
 				}),
 				id: "1275828087666679809",
-				opt: []*gotwtr.TweetLookUpOption{
+				opt: []*gotwtr.RetriveTweetOption{
 					{
 						TweetFields: []gotwtr.TweetField{
 							gotwtr.TweetFieldAttachments,
@@ -509,7 +509,7 @@ func Test_lookUpByID(t *testing.T) {
 					},
 				},
 			},
-			want: &gotwtr.TweetLookUpByIDResponse{
+			want: &gotwtr.TweetResponse{
 				Tweet: &gotwtr.Tweet{
 					AuthorID:  "2244994945",
 					CreatedAt: "2020-06-24T16:28:14.000Z",
@@ -596,7 +596,7 @@ func Test_lookUpByID(t *testing.T) {
 					}
 				}),
 				id: "1276230436478386177",
-				opt: []*gotwtr.TweetLookUpOption{
+				opt: []*gotwtr.RetriveTweetOption{
 					{
 						TweetFields: []gotwtr.TweetField{
 							gotwtr.TweetFieldAttachments,
@@ -616,7 +616,7 @@ func Test_lookUpByID(t *testing.T) {
 					},
 				},
 			},
-			want: &gotwtr.TweetLookUpByIDResponse{
+			want: &gotwtr.TweetResponse{
 				Errors: []*gotwtr.APIResponseError{
 					{
 						Value:        "1276230436478386177",
@@ -673,7 +673,7 @@ func Test_lookUpByID(t *testing.T) {
 					}
 				}),
 				id: "1136017751028449283",
-				opt: []*gotwtr.TweetLookUpOption{
+				opt: []*gotwtr.RetriveTweetOption{
 					{
 						Expansions: []gotwtr.Expansion{
 							gotwtr.ExpansionGeoPlaceID,
@@ -691,7 +691,7 @@ func Test_lookUpByID(t *testing.T) {
 					},
 				},
 			},
-			want: &gotwtr.TweetLookUpByIDResponse{
+			want: &gotwtr.TweetResponse{
 				Tweet: &gotwtr.Tweet{
 					Geo: &gotwtr.TweetGeo{
 						PlaceID: "01a9a39529b27f36",
@@ -767,7 +767,7 @@ func Test_lookUpByID(t *testing.T) {
 					}
 				}),
 				id: "1199786642791452673",
-				opt: []*gotwtr.TweetLookUpOption{
+				opt: []*gotwtr.RetriveTweetOption{
 					{
 						Expansions: []gotwtr.Expansion{
 							gotwtr.ExpansionAttachmentsPollIDs,
@@ -782,7 +782,7 @@ func Test_lookUpByID(t *testing.T) {
 					},
 				},
 			},
-			want: &gotwtr.TweetLookUpByIDResponse{
+			want: &gotwtr.TweetResponse{
 				Tweet: &gotwtr.Tweet{
 					Attachments: &gotwtr.TweetAttachment{
 						PollIDs: []string{
@@ -870,7 +870,7 @@ func Test_lookUpByID(t *testing.T) {
 					}
 				}),
 				id: "1263145271946551300",
-				opt: []*gotwtr.TweetLookUpOption{
+				opt: []*gotwtr.RetriveTweetOption{
 					{
 						TweetFields: []gotwtr.TweetField{
 							gotwtr.TweetFieldAttachments,
@@ -903,7 +903,7 @@ func Test_lookUpByID(t *testing.T) {
 					},
 				},
 			},
-			want: &gotwtr.TweetLookUpByIDResponse{
+			want: &gotwtr.TweetResponse{
 				Tweet: &gotwtr.Tweet{
 					Attachments: &gotwtr.TweetAttachment{
 						MediaKeys: []string{
@@ -952,13 +952,13 @@ func Test_lookUpByID(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			c := gotwtr.New("test-key", gotwtr.WithHTTPClient(tt.args.client))
-			got, err := c.LookUpTweetByID(tt.args.ctx, tt.args.id, tt.args.opt...)
+			got, err := c.RetriveSingleTweet(tt.args.ctx, tt.args.id, tt.args.opt...)
 			if (err != nil) != tt.wantErr {
-				t.Errorf("client.LookUpTweetByID() error = %v, wantErr %v", err, tt.wantErr)
+				t.Errorf("client.RetriveSingleTweet() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
 			if diff := cmp.Diff(tt.want, got); diff != "" {
-				t.Errorf("client.LookUpTweetByID() mismatch (-want +got):\n%s", diff)
+				t.Errorf("client.RetriveSingleTweet() mismatch (-want +got):\n%s", diff)
 				return
 			}
 		})
diff --git a/user_lookup_test.go b/user_lookup_test.go
index b95989b..18c21af 100644
--- a/user_lookup_test.go
+++ b/user_lookup_test.go
@@ -11,18 +11,18 @@ import (
 	"github.com/sivchari/gotwtr"
 )
 
-func Test_lookUpUsers(t *testing.T) {
+func Test_retrieveMultipleUsersWithIDs(t *testing.T) {
 	t.Parallel()
 	type args struct {
 		ctx    context.Context
 		client *http.Client
 		ids    []string
-		opt    []*gotwtr.UserLookUpOption
+		opt    []*gotwtr.RetrieveUserOption
 	}
 	tests := []struct {
 		name    string
 		args    args
-		want    *gotwtr.UserLookUpResponse
+		want    *gotwtr.UsersResponse
 		wantErr bool
 	}{
 		{
@@ -45,9 +45,9 @@ func Test_lookUpUsers(t *testing.T) {
 					}
 				}),
 				ids: []string{"2244994945"},
-				opt: []*gotwtr.UserLookUpOption{},
+				opt: []*gotwtr.RetrieveUserOption{},
 			},
-			want: &gotwtr.UserLookUpResponse{
+			want: &gotwtr.UsersResponse{
 				Users: []*gotwtr.User{
 					{
 						ID:       "2244994945",
@@ -96,7 +96,7 @@ func Test_lookUpUsers(t *testing.T) {
 					}
 				}),
 				ids: []string{"2244994945"},
-				opt: []*gotwtr.UserLookUpOption{
+				opt: []*gotwtr.RetrieveUserOption{
 					{
 						Expansions: []gotwtr.Expansion{gotwtr.ExpansionAuthorID},
 						TweetFields: []gotwtr.TweetField{
@@ -109,7 +109,7 @@ func Test_lookUpUsers(t *testing.T) {
 					},
 				},
 			},
-			want: &gotwtr.UserLookUpResponse{
+			want: &gotwtr.UsersResponse{
 				Users: []*gotwtr.User{
 					{
 						CreatedAt:     "2013-12-14T04:35:55.000Z",
@@ -162,9 +162,9 @@ func Test_lookUpUsers(t *testing.T) {
 					}
 				}),
 				ids: []string{"2244994945", "783214"},
-				opt: []*gotwtr.UserLookUpOption{},
+				opt: []*gotwtr.RetrieveUserOption{},
 			},
-			want: &gotwtr.UserLookUpResponse{
+			want: &gotwtr.UsersResponse{
 				Users: []*gotwtr.User{
 					{
 						ID:       "2244994945",
@@ -225,7 +225,7 @@ func Test_lookUpUsers(t *testing.T) {
 					}
 				}),
 				ids: []string{"2244994945", "783214"},
-				opt: []*gotwtr.UserLookUpOption{
+				opt: []*gotwtr.RetrieveUserOption{
 					{
 						Expansions: []gotwtr.Expansion{gotwtr.ExpansionAuthorID},
 						TweetFields: []gotwtr.TweetField{
@@ -238,7 +238,7 @@ func Test_lookUpUsers(t *testing.T) {
 					},
 				},
 			},
-			want: &gotwtr.UserLookUpResponse{
+			want: &gotwtr.UsersResponse{
 				Users: []*gotwtr.User{
 					{
 						CreatedAt:     "2013-12-14T04:35:55.000Z",
@@ -303,9 +303,9 @@ func Test_lookUpUsers(t *testing.T) {
 					}
 				}),
 				ids: []string{"6253282", "11111111111"},
-				opt: []*gotwtr.UserLookUpOption{},
+				opt: []*gotwtr.RetrieveUserOption{},
 			},
-			want: &gotwtr.UserLookUpResponse{
+			want: &gotwtr.UsersResponse{
 				Users: []*gotwtr.User{
 					{
 						ID:       "6253282",
@@ -360,9 +360,9 @@ func Test_lookUpUsers(t *testing.T) {
 					}
 				}),
 				ids: []string{"11111111111", "22222222222"},
-				opt: []*gotwtr.UserLookUpOption{},
+				opt: []*gotwtr.RetrieveUserOption{},
 			},
-			want: &gotwtr.UserLookUpResponse{
+			want: &gotwtr.UsersResponse{
 				Users: nil,
 				Errors: []*gotwtr.APIResponseError{
 					{
@@ -393,31 +393,31 @@ func Test_lookUpUsers(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			c := gotwtr.New("test-key", gotwtr.WithHTTPClient(tt.args.client))
-			got, err := c.LookUpUsers(tt.args.ctx, tt.args.ids, tt.args.opt...)
+			got, err := c.RetrieveMultipleUsersWithIDs(tt.args.ctx, tt.args.ids, tt.args.opt...)
 			if (err != nil) != tt.wantErr {
-				t.Errorf("client.LookUpUsers() error = %v, wantErr %v", err, tt.wantErr)
+				t.Errorf("client.RetriveMultipleUsersWithIDs() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
 			if diff := cmp.Diff(tt.want, got); diff != "" {
-				t.Errorf("client.LookUpUsers() mismatch (-want +got):\n%s", diff)
+				t.Errorf("client.RetriveMultipleUsersWithIDs() mismatch (-want +got):\n%s", diff)
 				return
 			}
 		})
 	}
 }
 
-func Test_lookUpUserByID(t *testing.T) {
+func Test_retrieveSingleUserWithID(t *testing.T) {
 	t.Parallel()
 	type args struct {
 		ctx    context.Context
 		client *http.Client
 		id     string
-		opt    []*gotwtr.UserLookUpOption
+		opt    []*gotwtr.RetrieveUserOption
 	}
 	tests := []struct {
 		name    string
 		args    args
-		want    *gotwtr.UserLookUpByIDResponse
+		want    *gotwtr.UserResponse
 		wantErr bool
 	}{
 		{
@@ -438,9 +438,9 @@ func Test_lookUpUserByID(t *testing.T) {
 					}
 				}),
 				id:  "2244994945",
-				opt: []*gotwtr.UserLookUpOption{},
+				opt: []*gotwtr.RetrieveUserOption{},
 			},
-			want: &gotwtr.UserLookUpByIDResponse{
+			want: &gotwtr.UserResponse{
 				User: &gotwtr.User{
 					ID:       "2244994945",
 					Name:     "Twitter Dev",
@@ -478,7 +478,7 @@ func Test_lookUpUserByID(t *testing.T) {
 					}
 				}),
 				id: "2244994945",
-				opt: []*gotwtr.UserLookUpOption{
+				opt: []*gotwtr.RetrieveUserOption{
 					{
 						Expansions: []gotwtr.Expansion{gotwtr.ExpansionAuthorID},
 						TweetFields: []gotwtr.TweetField{
@@ -491,7 +491,7 @@ func Test_lookUpUserByID(t *testing.T) {
 					},
 				},
 			},
-			want: &gotwtr.UserLookUpByIDResponse{
+			want: &gotwtr.UserResponse{
 				User: &gotwtr.User{
 					UserName:      "TwitterDev",
 					CreatedAt:     "2013-12-14T04:35:55.000Z",
@@ -535,9 +535,9 @@ func Test_lookUpUserByID(t *testing.T) {
 					}
 				}),
 				id:  "11111111111",
-				opt: []*gotwtr.UserLookUpOption{},
+				opt: []*gotwtr.RetrieveUserOption{},
 			},
-			want: &gotwtr.UserLookUpByIDResponse{
+			want: &gotwtr.UserResponse{
 				User: nil,
 				Errors: []*gotwtr.APIResponseError{
 					{
@@ -559,31 +559,31 @@ func Test_lookUpUserByID(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			c := gotwtr.New("test-key", gotwtr.WithHTTPClient(tt.args.client))
-			got, err := c.LookUpUserByID(tt.args.ctx, tt.args.id, tt.args.opt...)
+			got, err := c.RetrieveSingleUserWithID(tt.args.ctx, tt.args.id, tt.args.opt...)
 			if (err != nil) != tt.wantErr {
-				t.Errorf("client.LookUpUserByID() error = %v, wantErr %v", err, tt.wantErr)
+				t.Errorf("client.RetriveSingleUserWithID() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
 			if diff := cmp.Diff(tt.want, got); diff != "" {
-				t.Errorf("client.LookUpUserByID() mismatch (-want +got):\n%s", diff)
+				t.Errorf("client.RetriveSingleUserWithID() mismatch (-want +got):\n%s", diff)
 				return
 			}
 		})
 	}
 }
 
-func Test_lookUpUserByUserName(t *testing.T) {
+func Test_retrieveSingleUserWithUserName(t *testing.T) {
 	t.Parallel()
 	type args struct {
 		ctx    context.Context
 		client *http.Client
 		name   string
-		opt    []*gotwtr.UserLookUpOption
+		opt    []*gotwtr.RetrieveUserOption
 	}
 	tests := []struct {
 		name    string
 		args    args
-		want    *gotwtr.UserLookUpByUserNameResponse
+		want    *gotwtr.UserResponse
 		wantErr bool
 	}{
 		{
@@ -604,9 +604,9 @@ func Test_lookUpUserByUserName(t *testing.T) {
 					}
 				}),
 				name: "TwitterDev",
-				opt:  []*gotwtr.UserLookUpOption{},
+				opt:  []*gotwtr.RetrieveUserOption{},
 			},
-			want: &gotwtr.UserLookUpByUserNameResponse{
+			want: &gotwtr.UserResponse{
 				User: &gotwtr.User{
 					ID:       "2244994945",
 					Name:     "Twitter Dev",
@@ -644,7 +644,7 @@ func Test_lookUpUserByUserName(t *testing.T) {
 					}
 				}),
 				name: "TwitterDev",
-				opt: []*gotwtr.UserLookUpOption{
+				opt: []*gotwtr.RetrieveUserOption{
 					{
 						Expansions: []gotwtr.Expansion{gotwtr.ExpansionAuthorID},
 						TweetFields: []gotwtr.TweetField{
@@ -657,7 +657,7 @@ func Test_lookUpUserByUserName(t *testing.T) {
 					},
 				},
 			},
-			want: &gotwtr.UserLookUpByUserNameResponse{
+			want: &gotwtr.UserResponse{
 				User: &gotwtr.User{
 					UserName:      "TwitterDev",
 					CreatedAt:     "2013-12-14T04:35:55.000Z",
@@ -703,9 +703,9 @@ func Test_lookUpUserByUserName(t *testing.T) {
 					}
 				}),
 				name: "aaaaaaaaaaaaaaaaaa",
-				opt:  []*gotwtr.UserLookUpOption{},
+				opt:  []*gotwtr.RetrieveUserOption{},
 			},
-			want: &gotwtr.UserLookUpByUserNameResponse{
+			want: &gotwtr.UserResponse{
 				User: nil,
 				Errors: []*gotwtr.APIResponseError{
 					{
@@ -722,35 +722,35 @@ func Test_lookUpUserByUserName(t *testing.T) {
 			wantErr: true,
 		},
 	}
-	for i, tt := range tests {
+	for _, tt := range tests {
 		tt := tt
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			c := gotwtr.New("test-key", gotwtr.WithHTTPClient(tt.args.client))
-			got, err := c.LookUpUserByUserName(tt.args.ctx, tt.args.name, tt.args.opt...)
+			got, err := c.RetrieveSingleUserWithUserName(tt.args.ctx, tt.args.name, tt.args.opt...)
 			if (err != nil) != tt.wantErr {
-				t.Errorf("client.LookUpUserByUserName() index = %v error = %v, wantErr %v", i, err, tt.wantErr)
+				t.Errorf("client.RetrieveSingleUserWithUserName() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
 			if diff := cmp.Diff(got, tt.want); diff != "" {
-				t.Errorf("client.LookUpUserByUserName() index = %v mismatch (-want +got):\n%s", i, diff)
+				t.Errorf("client.RetrieveSingleUserWithUserName() mismatch (-want +got):\n%s", diff)
 				return
 			}
 		})
 	}
 }
 
-func Test_lookUpUsersByUserNames(t *testing.T) {
+func Test_retrieveMultipleUsersWithUserNames(t *testing.T) {
 	type args struct {
 		ctx    context.Context
 		client *http.Client
 		names  []string
-		opt    []*gotwtr.UserLookUpOption
+		opt    []*gotwtr.RetrieveUserOption
 	}
 	tests := []struct {
 		name    string
 		args    args
-		want    *gotwtr.UsersLookUpByUserNamesResponse
+		want    *gotwtr.UsersResponse
 		wantErr bool
 	}{
 		{
@@ -778,9 +778,9 @@ func Test_lookUpUsersByUserNames(t *testing.T) {
 					}
 				}),
 				names: []string{"TwitterDev", "Twitter"},
-				opt:   []*gotwtr.UserLookUpOption{},
+				opt:   []*gotwtr.RetrieveUserOption{},
 			},
-			want: &gotwtr.UsersLookUpByUserNamesResponse{
+			want: &gotwtr.UsersResponse{
 				Users: []*gotwtr.User{
 					{
 						ID:       "2244994945",
@@ -839,7 +839,7 @@ func Test_lookUpUsersByUserNames(t *testing.T) {
 					}
 				}),
 				names: []string{"TwitterDev", "Twitter"},
-				opt: []*gotwtr.UserLookUpOption{
+				opt: []*gotwtr.RetrieveUserOption{
 					{
 						Expansions: []gotwtr.Expansion{gotwtr.ExpansionAuthorID},
 						TweetFields: []gotwtr.TweetField{
@@ -852,7 +852,7 @@ func Test_lookUpUsersByUserNames(t *testing.T) {
 					},
 				},
 			},
-			want: &gotwtr.UsersLookUpByUserNamesResponse{
+			want: &gotwtr.UsersResponse{
 				Users: []*gotwtr.User{
 					{
 						CreatedAt:     "2013-12-14T04:35:55.000Z",
@@ -920,9 +920,9 @@ func Test_lookUpUsersByUserNames(t *testing.T) {
 					}
 				}),
 				names: []string{"aaaaaaaaaaaaaaaaaaaaaa", "bbbbbbbbbbbbbbbbbbbbbbbb"},
-				opt:   []*gotwtr.UserLookUpOption{},
+				opt:   []*gotwtr.RetrieveUserOption{},
 			},
-			want: &gotwtr.UsersLookUpByUserNamesResponse{
+			want: &gotwtr.UsersResponse{
 				Users: nil,
 				Errors: []*gotwtr.APIResponseError{
 					{
@@ -950,13 +950,13 @@ func Test_lookUpUsersByUserNames(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 			c := gotwtr.New("test-key", gotwtr.WithHTTPClient(tt.args.client))
-			got, err := c.LookUpUsersByUserNames(tt.args.ctx, tt.args.names, tt.args.opt...)
+			got, err := c.RetrieveMultipleUsersWithUserNames(tt.args.ctx, tt.args.names, tt.args.opt...)
 			if (err != nil) != tt.wantErr {
-				t.Errorf("client.LookUpUsersByUserNames() error = %v, wantErr %v", err, tt.wantErr)
+				t.Errorf("client.RetrieveMultipleUsersWithUserNames() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
 			if diff := cmp.Diff(tt.want, got); diff != "" {
-				t.Errorf("client.LookUpUsersByUserNames() mismatch (-want +got):\n%s", diff)
+				t.Errorf("client.RetrieveMultipleUsersWithUserNames() mismatch (-want +got):\n%s", diff)
 				return
 			}
 		})
diff --git a/sampled_stream_test.go b/volume_stream_test.go
similarity index 79%
rename from sampled_stream_test.go
rename to volume_stream_test.go
index 5ab11a6..cd43c96 100644
--- a/sampled_stream_test.go
+++ b/volume_stream_test.go
@@ -16,12 +16,12 @@ func Test_sampledStream(t *testing.T) {
 	type args struct {
 		ctx    context.Context
 		client *http.Client
-		opt    []*gotwtr.SampledStreamOpts
+		opt    []*gotwtr.VolumeStreamsOption
 	}
 	tests := []struct {
 		name    string
 		args    args
-		want    *gotwtr.SampledStreamResponse
+		want    *gotwtr.VolumeStreamsResponse
 		wantErr bool
 	}{
 		{
@@ -40,9 +40,9 @@ func Test_sampledStream(t *testing.T) {
 						Body:       io.NopCloser(strings.NewReader(body)),
 					}
 				}),
-				opt: []*gotwtr.SampledStreamOpts{},
+				opt: []*gotwtr.VolumeStreamsOption{},
 			},
-			want: &gotwtr.SampledStreamResponse{
+			want: &gotwtr.VolumeStreamsResponse{
 				Tweet: &gotwtr.Tweet{
 					ID:   "1067094924124872705",
 					Text: "Just getting started with Twitter APIs? Find out what you need in order to build an app. Watch this video! https://t.co/Hg8nkfoizN",
@@ -55,19 +55,19 @@ func Test_sampledStream(t *testing.T) {
 		tt := tt
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			ch := make(chan gotwtr.SampledStreamResponse)
+			ch := make(chan gotwtr.VolumeStreamsResponse)
 			errCh := make(chan error)
 			c := gotwtr.New("test-key", gotwtr.WithHTTPClient(tt.args.client))
-			c.SampledStream(tt.args.ctx, ch, errCh, tt.args.opt...)
+			c.VolumeStreams(tt.args.ctx, ch, errCh, tt.args.opt...)
 			select {
 			case got := <-ch:
 				if diff := cmp.Diff(tt.want, &got); diff != "" {
-					t.Errorf("client.SampledStream() mismatch (-want +got):\n%s", diff)
+					t.Errorf("client.VolumeStreams() mismatch (-want +got):\n%s", diff)
 					return
 				}
 			case err := <-errCh:
 				if (err != nil) != tt.wantErr {
-					t.Errorf("client.SampledStream() error = %v, wantErr %v", err, tt.wantErr)
+					t.Errorf("client.VolumeStreams() error = %v, wantErr %v", err, tt.wantErr)
 					return
 				}
 			}