update lexgen types to not send go zero vals as URL params for optional fields (#1077)

api/agnostic/repogetRecord.go

···
 	var out RepoGetRecord_Output
 
 	params := map[string]interface{}{
-		"cid":        cid,
 		"collection": collection,
 		"repo":       repo,
 		"rkey":       rkey,
+	}
+	if cid != "" {
+		params["cid"] = cid
 	}
 	if err := c.LexDo(ctx, util.Query, "", "com.atproto.repo.getRecord", params, nil, &out); err != nil {
 		return nil, err

api/agnostic/repolistRecords.go

···
 
 	params := map[string]interface{}{
 		"collection": collection,
-		"cursor":     cursor,
-		"limit":      limit,
 		"repo":       repo,
-		"reverse":    reverse,
+	}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
+	if reverse != false {
+		params["reverse"] = reverse
+	}
+
 	if err := c.LexDo(ctx, util.Query, "", "com.atproto.repo.listRecords", params, nil, &out); err != nil {
 		return nil, err
 	}

api/atproto/admingetAccountInfo.go

···
 func AdminGetAccountInfo(ctx context.Context, c *xrpc.Client, did string) (*AdminDefs_AccountView, error) {
 	var out AdminDefs_AccountView
 
-	params := map[string]interface{}{
-		"did": did,
-	}
+	params := map[string]interface{}{}
+	params["did"] = did
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.admin.getAccountInfo", params, nil, &out); err != nil {
 		return nil, err
 	}

api/atproto/admingetAccountInfos.go

···
 func AdminGetAccountInfos(ctx context.Context, c *xrpc.Client, dids []string) (*AdminGetAccountInfos_Output, error) {
 	var out AdminGetAccountInfos_Output
 
-	params := map[string]interface{}{
-		"dids": dids,
-	}
+	params := map[string]interface{}{}
+	params["dids"] = dids
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.admin.getAccountInfos", params, nil, &out); err != nil {
 		return nil, err
 	}

api/atproto/admingetInviteCodes.go

···
 func AdminGetInviteCodes(ctx context.Context, c *xrpc.Client, cursor string, limit int64, sort string) (*AdminGetInviteCodes_Output, error) {
 	var out AdminGetInviteCodes_Output
 
-	params := map[string]interface{}{
-		"cursor": cursor,
-		"limit":  limit,
-		"sort":   sort,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if sort != "" {
+		params["sort"] = sort
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.admin.getInviteCodes", params, nil, &out); err != nil {
 		return nil, err

api/atproto/admingetSubjectStatus.go

···
 func AdminGetSubjectStatus(ctx context.Context, c *xrpc.Client, blob string, did string, uri string) (*AdminGetSubjectStatus_Output, error) {
 	var out AdminGetSubjectStatus_Output
 
-	params := map[string]interface{}{
-		"blob": blob,
-		"did":  did,
-		"uri":  uri,
+	params := map[string]interface{}{}
+	if blob != "" {
+		params["blob"] = blob
+	}
+	if did != "" {
+		params["did"] = did
+	}
+	if uri != "" {
+		params["uri"] = uri
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.admin.getSubjectStatus", params, nil, &out); err != nil {
 		return nil, err

api/atproto/adminsearchAccounts.go

···
 func AdminSearchAccounts(ctx context.Context, c *xrpc.Client, cursor string, email string, limit int64) (*AdminSearchAccounts_Output, error) {
 	var out AdminSearchAccounts_Output
 
-	params := map[string]interface{}{
-		"cursor": cursor,
-		"email":  email,
-		"limit":  limit,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if email != "" {
+		params["email"] = email
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.admin.searchAccounts", params, nil, &out); err != nil {
 		return nil, err

api/atproto/identityresolveDid.go

···
 func IdentityResolveDid(ctx context.Context, c *xrpc.Client, did string) (*IdentityResolveDid_Output, error) {
 	var out IdentityResolveDid_Output
 
-	params := map[string]interface{}{
-		"did": did,
-	}
+	params := map[string]interface{}{}
+	params["did"] = did
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.identity.resolveDid", params, nil, &out); err != nil {
 		return nil, err
 	}

api/atproto/identityresolveHandle.go

···
 func IdentityResolveHandle(ctx context.Context, c *xrpc.Client, handle string) (*IdentityResolveHandle_Output, error) {
 	var out IdentityResolveHandle_Output
 
-	params := map[string]interface{}{
-		"handle": handle,
-	}
+	params := map[string]interface{}{}
+	params["handle"] = handle
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.identity.resolveHandle", params, nil, &out); err != nil {
 		return nil, err
 	}

api/atproto/identityresolveIdentity.go

···
 func IdentityResolveIdentity(ctx context.Context, c *xrpc.Client, identifier string) (*IdentityDefs_IdentityInfo, error) {
 	var out IdentityDefs_IdentityInfo
 
-	params := map[string]interface{}{
-		"identifier": identifier,
-	}
+	params := map[string]interface{}{}
+	params["identifier"] = identifier
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.identity.resolveIdentity", params, nil, &out); err != nil {
 		return nil, err
 	}

api/atproto/labelqueryLabels.go

···
 func LabelQueryLabels(ctx context.Context, c *xrpc.Client, cursor string, limit int64, sources []string, uriPatterns []string) (*LabelQueryLabels_Output, error) {
 	var out LabelQueryLabels_Output
 
-	params := map[string]interface{}{
-		"cursor":      cursor,
-		"limit":       limit,
-		"sources":     sources,
-		"uriPatterns": uriPatterns,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if len(sources) != 0 {
+		params["sources"] = sources
 	}
+	params["uriPatterns"] = uriPatterns
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.label.queryLabels", params, nil, &out); err != nil {
 		return nil, err
 	}

api/atproto/repodescribeRepo.go

···
 func RepoDescribeRepo(ctx context.Context, c *xrpc.Client, repo string) (*RepoDescribeRepo_Output, error) {
 	var out RepoDescribeRepo_Output
 
-	params := map[string]interface{}{
-		"repo": repo,
-	}
+	params := map[string]interface{}{}
+	params["repo"] = repo
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.repo.describeRepo", params, nil, &out); err != nil {
 		return nil, err
 	}

api/atproto/repogetRecord.go

···
 func RepoGetRecord(ctx context.Context, c *xrpc.Client, cid string, collection string, repo string, rkey string) (*RepoGetRecord_Output, error) {
 	var out RepoGetRecord_Output
 
-	params := map[string]interface{}{
-		"cid":        cid,
-		"collection": collection,
-		"repo":       repo,
-		"rkey":       rkey,
+	params := map[string]interface{}{}
+	if cid != "" {
+		params["cid"] = cid
 	}
+	params["collection"] = collection
+	params["repo"] = repo
+	params["rkey"] = rkey
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.repo.getRecord", params, nil, &out); err != nil {
 		return nil, err
 	}

api/atproto/repolistMissingBlobs.go

···
 func RepoListMissingBlobs(ctx context.Context, c *xrpc.Client, cursor string, limit int64) (*RepoListMissingBlobs_Output, error) {
 	var out RepoListMissingBlobs_Output
 
-	params := map[string]interface{}{
-		"cursor": cursor,
-		"limit":  limit,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.repo.listMissingBlobs", params, nil, &out); err != nil {
 		return nil, err

api/atproto/repolistRecords.go

···
 func RepoListRecords(ctx context.Context, c *xrpc.Client, collection string, cursor string, limit int64, repo string, reverse bool) (*RepoListRecords_Output, error) {
 	var out RepoListRecords_Output
 
-	params := map[string]interface{}{
-		"collection": collection,
-		"cursor":     cursor,
-		"limit":      limit,
-		"repo":       repo,
-		"reverse":    reverse,
+	params := map[string]interface{}{}
+	params["collection"] = collection
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	params["repo"] = repo
+	if reverse {
+		params["reverse"] = reverse
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.repo.listRecords", params, nil, &out); err != nil {
 		return nil, err

api/atproto/servergetAccountInviteCodes.go

···
 func ServerGetAccountInviteCodes(ctx context.Context, c *xrpc.Client, createAvailable bool, includeUsed bool) (*ServerGetAccountInviteCodes_Output, error) {
 	var out ServerGetAccountInviteCodes_Output
 
-	params := map[string]interface{}{
-		"createAvailable": createAvailable,
-		"includeUsed":     includeUsed,
+	params := map[string]interface{}{}
+	if createAvailable {
+		params["createAvailable"] = createAvailable
+	}
+	if includeUsed {
+		params["includeUsed"] = includeUsed
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.server.getAccountInviteCodes", params, nil, &out); err != nil {
 		return nil, err

api/atproto/servergetServiceAuth.go

···
 func ServerGetServiceAuth(ctx context.Context, c *xrpc.Client, aud string, exp int64, lxm string) (*ServerGetServiceAuth_Output, error) {
 	var out ServerGetServiceAuth_Output
 
-	params := map[string]interface{}{
-		"aud": aud,
-		"exp": exp,
-		"lxm": lxm,
+	params := map[string]interface{}{}
+	params["aud"] = aud
+	if exp != 0 {
+		params["exp"] = exp
+	}
+	if lxm != "" {
+		params["lxm"] = lxm
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.server.getServiceAuth", params, nil, &out); err != nil {
 		return nil, err

api/atproto/syncgetBlob.go

···
 func SyncGetBlob(ctx context.Context, c *xrpc.Client, cid string, did string) ([]byte, error) {
 	buf := new(bytes.Buffer)
 
-	params := map[string]interface{}{
-		"cid": cid,
-		"did": did,
-	}
+	params := map[string]interface{}{}
+	params["cid"] = cid
+	params["did"] = did
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.sync.getBlob", params, nil, buf); err != nil {
 		return nil, err
 	}

api/atproto/syncgetBlocks.go

···
 func SyncGetBlocks(ctx context.Context, c *xrpc.Client, cids []string, did string) ([]byte, error) {
 	buf := new(bytes.Buffer)
 
-	params := map[string]interface{}{
-		"cids": cids,
-		"did":  did,
-	}
+	params := map[string]interface{}{}
+	params["cids"] = cids
+	params["did"] = did
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.sync.getBlocks", params, nil, buf); err != nil {
 		return nil, err
 	}

api/atproto/syncgetCheckout.go

···
 func SyncGetCheckout(ctx context.Context, c *xrpc.Client, did string) ([]byte, error) {
 	buf := new(bytes.Buffer)
 
-	params := map[string]interface{}{
-		"did": did,
-	}
+	params := map[string]interface{}{}
+	params["did"] = did
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.sync.getCheckout", params, nil, buf); err != nil {
 		return nil, err
 	}

api/atproto/syncgetHead.go

···
 func SyncGetHead(ctx context.Context, c *xrpc.Client, did string) (*SyncGetHead_Output, error) {
 	var out SyncGetHead_Output
 
-	params := map[string]interface{}{
-		"did": did,
-	}
+	params := map[string]interface{}{}
+	params["did"] = did
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.sync.getHead", params, nil, &out); err != nil {
 		return nil, err
 	}

api/atproto/syncgetHostStatus.go

···
 func SyncGetHostStatus(ctx context.Context, c *xrpc.Client, hostname string) (*SyncGetHostStatus_Output, error) {
 	var out SyncGetHostStatus_Output
 
-	params := map[string]interface{}{
-		"hostname": hostname,
-	}
+	params := map[string]interface{}{}
+	params["hostname"] = hostname
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.sync.getHostStatus", params, nil, &out); err != nil {
 		return nil, err
 	}

api/atproto/syncgetLatestCommit.go

···
 func SyncGetLatestCommit(ctx context.Context, c *xrpc.Client, did string) (*SyncGetLatestCommit_Output, error) {
 	var out SyncGetLatestCommit_Output
 
-	params := map[string]interface{}{
-		"did": did,
-	}
+	params := map[string]interface{}{}
+	params["did"] = did
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.sync.getLatestCommit", params, nil, &out); err != nil {
 		return nil, err
 	}

api/atproto/syncgetRecord.go

···
 func SyncGetRecord(ctx context.Context, c *xrpc.Client, collection string, did string, rkey string) ([]byte, error) {
 	buf := new(bytes.Buffer)
 
-	params := map[string]interface{}{
-		"collection": collection,
-		"did":        did,
-		"rkey":       rkey,
-	}
+	params := map[string]interface{}{}
+	params["collection"] = collection
+	params["did"] = did
+	params["rkey"] = rkey
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.sync.getRecord", params, nil, buf); err != nil {
 		return nil, err
 	}

api/atproto/syncgetRepo.go

···
 func SyncGetRepo(ctx context.Context, c *xrpc.Client, did string, since string) ([]byte, error) {
 	buf := new(bytes.Buffer)
 
-	params := map[string]interface{}{
-		"did":   did,
-		"since": since,
+	params := map[string]interface{}{}
+	params["did"] = did
+	if since != "" {
+		params["since"] = since
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.sync.getRepo", params, nil, buf); err != nil {
 		return nil, err

api/atproto/syncgetRepoStatus.go

···
 func SyncGetRepoStatus(ctx context.Context, c *xrpc.Client, did string) (*SyncGetRepoStatus_Output, error) {
 	var out SyncGetRepoStatus_Output
 
-	params := map[string]interface{}{
-		"did": did,
-	}
+	params := map[string]interface{}{}
+	params["did"] = did
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.sync.getRepoStatus", params, nil, &out); err != nil {
 		return nil, err
 	}

api/atproto/synclistBlobs.go

···
 func SyncListBlobs(ctx context.Context, c *xrpc.Client, cursor string, did string, limit int64, since string) (*SyncListBlobs_Output, error) {
 	var out SyncListBlobs_Output
 
-	params := map[string]interface{}{
-		"cursor": cursor,
-		"did":    did,
-		"limit":  limit,
-		"since":  since,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	params["did"] = did
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if since != "" {
+		params["since"] = since
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.sync.listBlobs", params, nil, &out); err != nil {
 		return nil, err

api/atproto/synclistHosts.go

···
 func SyncListHosts(ctx context.Context, c *xrpc.Client, cursor string, limit int64) (*SyncListHosts_Output, error) {
 	var out SyncListHosts_Output
 
-	params := map[string]interface{}{
-		"cursor": cursor,
-		"limit":  limit,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.sync.listHosts", params, nil, &out); err != nil {
 		return nil, err

api/atproto/synclistRepos.go

···
 func SyncListRepos(ctx context.Context, c *xrpc.Client, cursor string, limit int64) (*SyncListRepos_Output, error) {
 	var out SyncListRepos_Output
 
-	params := map[string]interface{}{
-		"cursor": cursor,
-		"limit":  limit,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.sync.listRepos", params, nil, &out); err != nil {
 		return nil, err

api/atproto/synclistReposByCollection.go

···
 func SyncListReposByCollection(ctx context.Context, c *xrpc.Client, collection string, cursor string, limit int64) (*SyncListReposByCollection_Output, error) {
 	var out SyncListReposByCollection_Output
 
-	params := map[string]interface{}{
-		"collection": collection,
-		"cursor":     cursor,
-		"limit":      limit,
+	params := map[string]interface{}{}
+	params["collection"] = collection
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.sync.listReposByCollection", params, nil, &out); err != nil {
 		return nil, err

api/atproto/tempfetchLabels.go

···
 func TempFetchLabels(ctx context.Context, c *xrpc.Client, limit int64, since int64) (*TempFetchLabels_Output, error) {
 	var out TempFetchLabels_Output
 
-	params := map[string]interface{}{
-		"limit": limit,
-		"since": since,
+	params := map[string]interface{}{}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if since != 0 {
+		params["since"] = since
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.temp.fetchLabels", params, nil, &out); err != nil {
 		return nil, err

api/bsky/actorgetProfile.go

···
 func ActorGetProfile(ctx context.Context, c *xrpc.Client, actor string) (*ActorDefs_ProfileViewDetailed, error) {
 	var out ActorDefs_ProfileViewDetailed
 
-	params := map[string]interface{}{
-		"actor": actor,
-	}
+	params := map[string]interface{}{}
+	params["actor"] = actor
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.actor.getProfile", params, nil, &out); err != nil {
 		return nil, err
 	}

api/bsky/actorgetProfiles.go

···
 func ActorGetProfiles(ctx context.Context, c *xrpc.Client, actors []string) (*ActorGetProfiles_Output, error) {
 	var out ActorGetProfiles_Output
 
-	params := map[string]interface{}{
-		"actors": actors,
-	}
+	params := map[string]interface{}{}
+	params["actors"] = actors
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.actor.getProfiles", params, nil, &out); err != nil {
 		return nil, err
 	}

api/bsky/actorgetSuggestions.go

···
 func ActorGetSuggestions(ctx context.Context, c *xrpc.Client, cursor string, limit int64) (*ActorGetSuggestions_Output, error) {
 	var out ActorGetSuggestions_Output
 
-	params := map[string]interface{}{
-		"cursor": cursor,
-		"limit":  limit,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.actor.getSuggestions", params, nil, &out); err != nil {
 		return nil, err

api/bsky/actorsearchActors.go

···
 func ActorSearchActors(ctx context.Context, c *xrpc.Client, cursor string, limit int64, q string, term string) (*ActorSearchActors_Output, error) {
 	var out ActorSearchActors_Output
 
-	params := map[string]interface{}{
-		"cursor": cursor,
-		"limit":  limit,
-		"q":      q,
-		"term":   term,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if q != "" {
+		params["q"] = q
+	}
+	if term != "" {
+		params["term"] = term
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.actor.searchActors", params, nil, &out); err != nil {
 		return nil, err

api/bsky/actorsearchActorsTypeahead.go

···
 func ActorSearchActorsTypeahead(ctx context.Context, c *xrpc.Client, limit int64, q string, term string) (*ActorSearchActorsTypeahead_Output, error) {
 	var out ActorSearchActorsTypeahead_Output
 
-	params := map[string]interface{}{
-		"limit": limit,
-		"q":     q,
-		"term":  term,
+	params := map[string]interface{}{}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if q != "" {
+		params["q"] = q
+	}
+	if term != "" {
+		params["term"] = term
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.actor.searchActorsTypeahead", params, nil, &out); err != nil {
 		return nil, err

api/bsky/feedgetActorFeeds.go

···
 func FeedGetActorFeeds(ctx context.Context, c *xrpc.Client, actor string, cursor string, limit int64) (*FeedGetActorFeeds_Output, error) {
 	var out FeedGetActorFeeds_Output
 
-	params := map[string]interface{}{
-		"actor":  actor,
-		"cursor": cursor,
-		"limit":  limit,
+	params := map[string]interface{}{}
+	params["actor"] = actor
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getActorFeeds", params, nil, &out); err != nil {
 		return nil, err

api/bsky/feedgetActorLikes.go

···
 func FeedGetActorLikes(ctx context.Context, c *xrpc.Client, actor string, cursor string, limit int64) (*FeedGetActorLikes_Output, error) {
 	var out FeedGetActorLikes_Output
 
-	params := map[string]interface{}{
-		"actor":  actor,
-		"cursor": cursor,
-		"limit":  limit,
+	params := map[string]interface{}{}
+	params["actor"] = actor
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getActorLikes", params, nil, &out); err != nil {
 		return nil, err

api/bsky/feedgetAuthorFeed.go

···
 func FeedGetAuthorFeed(ctx context.Context, c *xrpc.Client, actor string, cursor string, filter string, includePins bool, limit int64) (*FeedGetAuthorFeed_Output, error) {
 	var out FeedGetAuthorFeed_Output
 
-	params := map[string]interface{}{
-		"actor":       actor,
-		"cursor":      cursor,
-		"filter":      filter,
-		"includePins": includePins,
-		"limit":       limit,
+	params := map[string]interface{}{}
+	params["actor"] = actor
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if filter != "" {
+		params["filter"] = filter
+	}
+	if includePins {
+		params["includePins"] = includePins
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getAuthorFeed", params, nil, &out); err != nil {
 		return nil, err

api/bsky/feedgetFeed.go

···
 func FeedGetFeed(ctx context.Context, c *xrpc.Client, cursor string, feed string, limit int64) (*FeedGetFeed_Output, error) {
 	var out FeedGetFeed_Output
 
-	params := map[string]interface{}{
-		"cursor": cursor,
-		"feed":   feed,
-		"limit":  limit,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	params["feed"] = feed
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getFeed", params, nil, &out); err != nil {
 		return nil, err

api/bsky/feedgetFeedGenerator.go

···
 func FeedGetFeedGenerator(ctx context.Context, c *xrpc.Client, feed string) (*FeedGetFeedGenerator_Output, error) {
 	var out FeedGetFeedGenerator_Output
 
-	params := map[string]interface{}{
-		"feed": feed,
-	}
+	params := map[string]interface{}{}
+	params["feed"] = feed
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getFeedGenerator", params, nil, &out); err != nil {
 		return nil, err
 	}

api/bsky/feedgetFeedGenerators.go

···
 func FeedGetFeedGenerators(ctx context.Context, c *xrpc.Client, feeds []string) (*FeedGetFeedGenerators_Output, error) {
 	var out FeedGetFeedGenerators_Output
 
-	params := map[string]interface{}{
-		"feeds": feeds,
-	}
+	params := map[string]interface{}{}
+	params["feeds"] = feeds
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getFeedGenerators", params, nil, &out); err != nil {
 		return nil, err
 	}

api/bsky/feedgetFeedSkeleton.go

···
 func FeedGetFeedSkeleton(ctx context.Context, c *xrpc.Client, cursor string, feed string, limit int64) (*FeedGetFeedSkeleton_Output, error) {
 	var out FeedGetFeedSkeleton_Output
 
-	params := map[string]interface{}{
-		"cursor": cursor,
-		"feed":   feed,
-		"limit":  limit,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	params["feed"] = feed
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getFeedSkeleton", params, nil, &out); err != nil {
 		return nil, err

api/bsky/feedgetLikes.go

···
 func FeedGetLikes(ctx context.Context, c *xrpc.Client, cid string, cursor string, limit int64, uri string) (*FeedGetLikes_Output, error) {
 	var out FeedGetLikes_Output
 
-	params := map[string]interface{}{
-		"cid":    cid,
-		"cursor": cursor,
-		"limit":  limit,
-		"uri":    uri,
+	params := map[string]interface{}{}
+	if cid != "" {
+		params["cid"] = cid
+	}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
+	params["uri"] = uri
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getLikes", params, nil, &out); err != nil {
 		return nil, err
 	}

api/bsky/feedgetListFeed.go

···
 func FeedGetListFeed(ctx context.Context, c *xrpc.Client, cursor string, limit int64, list string) (*FeedGetListFeed_Output, error) {
 	var out FeedGetListFeed_Output
 
-	params := map[string]interface{}{
-		"cursor": cursor,
-		"limit":  limit,
-		"list":   list,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
+	params["list"] = list
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getListFeed", params, nil, &out); err != nil {
 		return nil, err
 	}

api/bsky/feedgetPostThread.go

···
 func FeedGetPostThread(ctx context.Context, c *xrpc.Client, depth int64, parentHeight int64, uri string) (*FeedGetPostThread_Output, error) {
 	var out FeedGetPostThread_Output
 
-	params := map[string]interface{}{
-		"depth":        depth,
-		"parentHeight": parentHeight,
-		"uri":          uri,
+	params := map[string]interface{}{}
+	if depth != 0 {
+		params["depth"] = depth
+	}
+	if parentHeight != 0 {
+		params["parentHeight"] = parentHeight
 	}
+	params["uri"] = uri
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getPostThread", params, nil, &out); err != nil {
 		return nil, err
 	}

api/bsky/feedgetPosts.go

···
 func FeedGetPosts(ctx context.Context, c *xrpc.Client, uris []string) (*FeedGetPosts_Output, error) {
 	var out FeedGetPosts_Output
 
-	params := map[string]interface{}{
-		"uris": uris,
-	}
+	params := map[string]interface{}{}
+	params["uris"] = uris
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getPosts", params, nil, &out); err != nil {
 		return nil, err
 	}

api/bsky/feedgetQuotes.go

···
 func FeedGetQuotes(ctx context.Context, c *xrpc.Client, cid string, cursor string, limit int64, uri string) (*FeedGetQuotes_Output, error) {
 	var out FeedGetQuotes_Output
 
-	params := map[string]interface{}{
-		"cid":    cid,
-		"cursor": cursor,
-		"limit":  limit,
-		"uri":    uri,
+	params := map[string]interface{}{}
+	if cid != "" {
+		params["cid"] = cid
+	}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
+	params["uri"] = uri
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getQuotes", params, nil, &out); err != nil {
 		return nil, err
 	}

api/bsky/feedgetRepostedBy.go

···
 func FeedGetRepostedBy(ctx context.Context, c *xrpc.Client, cid string, cursor string, limit int64, uri string) (*FeedGetRepostedBy_Output, error) {
 	var out FeedGetRepostedBy_Output
 
-	params := map[string]interface{}{
-		"cid":    cid,
-		"cursor": cursor,
-		"limit":  limit,
-		"uri":    uri,
+	params := map[string]interface{}{}
+	if cid != "" {
+		params["cid"] = cid
+	}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
+	params["uri"] = uri
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getRepostedBy", params, nil, &out); err != nil {
 		return nil, err
 	}

api/bsky/feedgetSuggestedFeeds.go

···
 func FeedGetSuggestedFeeds(ctx context.Context, c *xrpc.Client, cursor string, limit int64) (*FeedGetSuggestedFeeds_Output, error) {
 	var out FeedGetSuggestedFeeds_Output
 
-	params := map[string]interface{}{
-		"cursor": cursor,
-		"limit":  limit,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getSuggestedFeeds", params, nil, &out); err != nil {
 		return nil, err

api/bsky/feedgetTimeline.go

···
 func FeedGetTimeline(ctx context.Context, c *xrpc.Client, algorithm string, cursor string, limit int64) (*FeedGetTimeline_Output, error) {
 	var out FeedGetTimeline_Output
 
-	params := map[string]interface{}{
-		"algorithm": algorithm,
-		"cursor":    cursor,
-		"limit":     limit,
+	params := map[string]interface{}{}
+	if algorithm != "" {
+		params["algorithm"] = algorithm
+	}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getTimeline", params, nil, &out); err != nil {
 		return nil, err

api/bsky/feedsearchPosts.go

···
 func FeedSearchPosts(ctx context.Context, c *xrpc.Client, author string, cursor string, domain string, lang string, limit int64, mentions string, q string, since string, sort string, tag []string, until string, url string) (*FeedSearchPosts_Output, error) {
 	var out FeedSearchPosts_Output
 
-	params := map[string]interface{}{
-		"author":   author,
-		"cursor":   cursor,
-		"domain":   domain,
-		"lang":     lang,
-		"limit":    limit,
-		"mentions": mentions,
-		"q":        q,
-		"since":    since,
-		"sort":     sort,
-		"tag":      tag,
-		"until":    until,
-		"url":      url,
+	params := map[string]interface{}{}
+	if author != "" {
+		params["author"] = author
+	}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if domain != "" {
+		params["domain"] = domain
+	}
+	if lang != "" {
+		params["lang"] = lang
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if mentions != "" {
+		params["mentions"] = mentions
+	}
+	params["q"] = q
+	if since != "" {
+		params["since"] = since
+	}
+	if sort != "" {
+		params["sort"] = sort
+	}
+	if len(tag) != 0 {
+		params["tag"] = tag
+	}
+	if until != "" {
+		params["until"] = until
+	}
+	if url != "" {
+		params["url"] = url
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.searchPosts", params, nil, &out); err != nil {
 		return nil, err

api/bsky/graphgetActorStarterPacks.go

···
 func GraphGetActorStarterPacks(ctx context.Context, c *xrpc.Client, actor string, cursor string, limit int64) (*GraphGetActorStarterPacks_Output, error) {
 	var out GraphGetActorStarterPacks_Output
 
-	params := map[string]interface{}{
-		"actor":  actor,
-		"cursor": cursor,
-		"limit":  limit,
+	params := map[string]interface{}{}
+	params["actor"] = actor
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getActorStarterPacks", params, nil, &out); err != nil {
 		return nil, err

api/bsky/graphgetBlocks.go

···
 func GraphGetBlocks(ctx context.Context, c *xrpc.Client, cursor string, limit int64) (*GraphGetBlocks_Output, error) {
 	var out GraphGetBlocks_Output
 
-	params := map[string]interface{}{
-		"cursor": cursor,
-		"limit":  limit,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getBlocks", params, nil, &out); err != nil {
 		return nil, err

api/bsky/graphgetFollowers.go

···
 func GraphGetFollowers(ctx context.Context, c *xrpc.Client, actor string, cursor string, limit int64) (*GraphGetFollowers_Output, error) {
 	var out GraphGetFollowers_Output
 
-	params := map[string]interface{}{
-		"actor":  actor,
-		"cursor": cursor,
-		"limit":  limit,
+	params := map[string]interface{}{}
+	params["actor"] = actor
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getFollowers", params, nil, &out); err != nil {
 		return nil, err

api/bsky/graphgetFollows.go

···
 func GraphGetFollows(ctx context.Context, c *xrpc.Client, actor string, cursor string, limit int64) (*GraphGetFollows_Output, error) {
 	var out GraphGetFollows_Output
 
-	params := map[string]interface{}{
-		"actor":  actor,
-		"cursor": cursor,
-		"limit":  limit,
+	params := map[string]interface{}{}
+	params["actor"] = actor
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getFollows", params, nil, &out); err != nil {
 		return nil, err

api/bsky/graphgetKnownFollowers.go

···
 func GraphGetKnownFollowers(ctx context.Context, c *xrpc.Client, actor string, cursor string, limit int64) (*GraphGetKnownFollowers_Output, error) {
 	var out GraphGetKnownFollowers_Output
 
-	params := map[string]interface{}{
-		"actor":  actor,
-		"cursor": cursor,
-		"limit":  limit,
+	params := map[string]interface{}{}
+	params["actor"] = actor
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getKnownFollowers", params, nil, &out); err != nil {
 		return nil, err

api/bsky/graphgetList.go

···
 func GraphGetList(ctx context.Context, c *xrpc.Client, cursor string, limit int64, list string) (*GraphGetList_Output, error) {
 	var out GraphGetList_Output
 
-	params := map[string]interface{}{
-		"cursor": cursor,
-		"limit":  limit,
-		"list":   list,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
+	params["list"] = list
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getList", params, nil, &out); err != nil {
 		return nil, err
 	}

api/bsky/graphgetListBlocks.go

···
 func GraphGetListBlocks(ctx context.Context, c *xrpc.Client, cursor string, limit int64) (*GraphGetListBlocks_Output, error) {
 	var out GraphGetListBlocks_Output
 
-	params := map[string]interface{}{
-		"cursor": cursor,
-		"limit":  limit,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getListBlocks", params, nil, &out); err != nil {
 		return nil, err

api/bsky/graphgetListMutes.go

···
 func GraphGetListMutes(ctx context.Context, c *xrpc.Client, cursor string, limit int64) (*GraphGetListMutes_Output, error) {
 	var out GraphGetListMutes_Output
 
-	params := map[string]interface{}{
-		"cursor": cursor,
-		"limit":  limit,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getListMutes", params, nil, &out); err != nil {
 		return nil, err

api/bsky/graphgetLists.go

···
 func GraphGetLists(ctx context.Context, c *xrpc.Client, actor string, cursor string, limit int64) (*GraphGetLists_Output, error) {
 	var out GraphGetLists_Output
 
-	params := map[string]interface{}{
-		"actor":  actor,
-		"cursor": cursor,
-		"limit":  limit,
+	params := map[string]interface{}{}
+	params["actor"] = actor
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getLists", params, nil, &out); err != nil {
 		return nil, err

api/bsky/graphgetMutes.go

···
 func GraphGetMutes(ctx context.Context, c *xrpc.Client, cursor string, limit int64) (*GraphGetMutes_Output, error) {
 	var out GraphGetMutes_Output
 
-	params := map[string]interface{}{
-		"cursor": cursor,
-		"limit":  limit,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getMutes", params, nil, &out); err != nil {
 		return nil, err

api/bsky/graphgetRelationships.go

···
 func GraphGetRelationships(ctx context.Context, c *xrpc.Client, actor string, others []string) (*GraphGetRelationships_Output, error) {
 	var out GraphGetRelationships_Output
 
-	params := map[string]interface{}{
-		"actor":  actor,
-		"others": others,
+	params := map[string]interface{}{}
+	params["actor"] = actor
+	if len(others) != 0 {
+		params["others"] = others
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getRelationships", params, nil, &out); err != nil {
 		return nil, err

api/bsky/graphgetStarterPack.go

···
 func GraphGetStarterPack(ctx context.Context, c *xrpc.Client, starterPack string) (*GraphGetStarterPack_Output, error) {
 	var out GraphGetStarterPack_Output
 
-	params := map[string]interface{}{
-		"starterPack": starterPack,
-	}
+	params := map[string]interface{}{}
+	params["starterPack"] = starterPack
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getStarterPack", params, nil, &out); err != nil {
 		return nil, err
 	}

api/bsky/graphgetStarterPacks.go

···
 func GraphGetStarterPacks(ctx context.Context, c *xrpc.Client, uris []string) (*GraphGetStarterPacks_Output, error) {
 	var out GraphGetStarterPacks_Output
 
-	params := map[string]interface{}{
-		"uris": uris,
-	}
+	params := map[string]interface{}{}
+	params["uris"] = uris
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getStarterPacks", params, nil, &out); err != nil {
 		return nil, err
 	}

api/bsky/graphgetSuggestedFollowsByActor.go

···
 func GraphGetSuggestedFollowsByActor(ctx context.Context, c *xrpc.Client, actor string) (*GraphGetSuggestedFollowsByActor_Output, error) {
 	var out GraphGetSuggestedFollowsByActor_Output
 
-	params := map[string]interface{}{
-		"actor": actor,
-	}
+	params := map[string]interface{}{}
+	params["actor"] = actor
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getSuggestedFollowsByActor", params, nil, &out); err != nil {
 		return nil, err
 	}

api/bsky/graphsearchStarterPacks.go

···
 func GraphSearchStarterPacks(ctx context.Context, c *xrpc.Client, cursor string, limit int64, q string) (*GraphSearchStarterPacks_Output, error) {
 	var out GraphSearchStarterPacks_Output
 
-	params := map[string]interface{}{
-		"cursor": cursor,
-		"limit":  limit,
-		"q":      q,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
+	params["q"] = q
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.searchStarterPacks", params, nil, &out); err != nil {
 		return nil, err
 	}

api/bsky/labelergetServices.go

···
 func LabelerGetServices(ctx context.Context, c *xrpc.Client, detailed bool, dids []string) (*LabelerGetServices_Output, error) {
 	var out LabelerGetServices_Output
 
-	params := map[string]interface{}{
-		"detailed": detailed,
-		"dids":     dids,
+	params := map[string]interface{}{}
+	if detailed {
+		params["detailed"] = detailed
 	}
+	params["dids"] = dids
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.labeler.getServices", params, nil, &out); err != nil {
 		return nil, err
 	}

api/bsky/notificationgetUnreadCount.go

···
 func NotificationGetUnreadCount(ctx context.Context, c *xrpc.Client, priority bool, seenAt string) (*NotificationGetUnreadCount_Output, error) {
 	var out NotificationGetUnreadCount_Output
 
-	params := map[string]interface{}{
-		"priority": priority,
-		"seenAt":   seenAt,
+	params := map[string]interface{}{}
+	if priority {
+		params["priority"] = priority
+	}
+	if seenAt != "" {
+		params["seenAt"] = seenAt
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.notification.getUnreadCount", params, nil, &out); err != nil {
 		return nil, err

api/bsky/notificationlistNotifications.go

···
 func NotificationListNotifications(ctx context.Context, c *xrpc.Client, cursor string, limit int64, priority bool, reasons []string, seenAt string) (*NotificationListNotifications_Output, error) {
 	var out NotificationListNotifications_Output
 
-	params := map[string]interface{}{
-		"cursor":   cursor,
-		"limit":    limit,
-		"priority": priority,
-		"reasons":  reasons,
-		"seenAt":   seenAt,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if priority {
+		params["priority"] = priority
+	}
+	if len(reasons) != 0 {
+		params["reasons"] = reasons
+	}
+	if seenAt != "" {
+		params["seenAt"] = seenAt
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.notification.listNotifications", params, nil, &out); err != nil {
 		return nil, err

api/bsky/unspeccedgetPopularFeedGenerators.go

···
 func UnspeccedGetPopularFeedGenerators(ctx context.Context, c *xrpc.Client, cursor string, limit int64, query string) (*UnspeccedGetPopularFeedGenerators_Output, error) {
 	var out UnspeccedGetPopularFeedGenerators_Output
 
-	params := map[string]interface{}{
-		"cursor": cursor,
-		"limit":  limit,
-		"query":  query,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if query != "" {
+		params["query"] = query
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.getPopularFeedGenerators", params, nil, &out); err != nil {
 		return nil, err

api/bsky/unspeccedgetSuggestedFeeds.go

···
 func UnspeccedGetSuggestedFeeds(ctx context.Context, c *xrpc.Client, limit int64) (*UnspeccedGetSuggestedFeeds_Output, error) {
 	var out UnspeccedGetSuggestedFeeds_Output
 
-	params := map[string]interface{}{
-		"limit": limit,
+	params := map[string]interface{}{}
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.getSuggestedFeeds", params, nil, &out); err != nil {
 		return nil, err

api/bsky/unspeccedgetSuggestedFeedsSkeleton.go

···
 func UnspeccedGetSuggestedFeedsSkeleton(ctx context.Context, c *xrpc.Client, limit int64, viewer string) (*UnspeccedGetSuggestedFeedsSkeleton_Output, error) {
 	var out UnspeccedGetSuggestedFeedsSkeleton_Output
 
-	params := map[string]interface{}{
-		"limit":  limit,
-		"viewer": viewer,
+	params := map[string]interface{}{}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if viewer != "" {
+		params["viewer"] = viewer
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.getSuggestedFeedsSkeleton", params, nil, &out); err != nil {
 		return nil, err

api/bsky/unspeccedgetSuggestedStarterPacks.go

···
 func UnspeccedGetSuggestedStarterPacks(ctx context.Context, c *xrpc.Client, limit int64) (*UnspeccedGetSuggestedStarterPacks_Output, error) {
 	var out UnspeccedGetSuggestedStarterPacks_Output
 
-	params := map[string]interface{}{
-		"limit": limit,
+	params := map[string]interface{}{}
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.getSuggestedStarterPacks", params, nil, &out); err != nil {
 		return nil, err

api/bsky/unspeccedgetSuggestedStarterPacksSkeleton.go

···
 func UnspeccedGetSuggestedStarterPacksSkeleton(ctx context.Context, c *xrpc.Client, limit int64, viewer string) (*UnspeccedGetSuggestedStarterPacksSkeleton_Output, error) {
 	var out UnspeccedGetSuggestedStarterPacksSkeleton_Output
 
-	params := map[string]interface{}{
-		"limit":  limit,
-		"viewer": viewer,
+	params := map[string]interface{}{}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if viewer != "" {
+		params["viewer"] = viewer
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.getSuggestedStarterPacksSkeleton", params, nil, &out); err != nil {
 		return nil, err

api/bsky/unspeccedgetSuggestedUsers.go

···
 func UnspeccedGetSuggestedUsers(ctx context.Context, c *xrpc.Client, category string, limit int64) (*UnspeccedGetSuggestedUsers_Output, error) {
 	var out UnspeccedGetSuggestedUsers_Output
 
-	params := map[string]interface{}{
-		"category": category,
-		"limit":    limit,
+	params := map[string]interface{}{}
+	if category != "" {
+		params["category"] = category
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.getSuggestedUsers", params, nil, &out); err != nil {
 		return nil, err

api/bsky/unspeccedgetSuggestedUsersSkeleton.go

···
 func UnspeccedGetSuggestedUsersSkeleton(ctx context.Context, c *xrpc.Client, category string, limit int64, viewer string) (*UnspeccedGetSuggestedUsersSkeleton_Output, error) {
 	var out UnspeccedGetSuggestedUsersSkeleton_Output
 
-	params := map[string]interface{}{
-		"category": category,
-		"limit":    limit,
-		"viewer":   viewer,
+	params := map[string]interface{}{}
+	if category != "" {
+		params["category"] = category
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if viewer != "" {
+		params["viewer"] = viewer
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.getSuggestedUsersSkeleton", params, nil, &out); err != nil {
 		return nil, err

api/bsky/unspeccedgetSuggestionsSkeleton.go

···
 func UnspeccedGetSuggestionsSkeleton(ctx context.Context, c *xrpc.Client, cursor string, limit int64, relativeToDid string, viewer string) (*UnspeccedGetSuggestionsSkeleton_Output, error) {
 	var out UnspeccedGetSuggestionsSkeleton_Output
 
-	params := map[string]interface{}{
-		"cursor":        cursor,
-		"limit":         limit,
-		"relativeToDid": relativeToDid,
-		"viewer":        viewer,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if relativeToDid != "" {
+		params["relativeToDid"] = relativeToDid
+	}
+	if viewer != "" {
+		params["viewer"] = viewer
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.getSuggestionsSkeleton", params, nil, &out); err != nil {
 		return nil, err

api/bsky/unspeccedgetTrendingTopics.go

···
 func UnspeccedGetTrendingTopics(ctx context.Context, c *xrpc.Client, limit int64, viewer string) (*UnspeccedGetTrendingTopics_Output, error) {
 	var out UnspeccedGetTrendingTopics_Output
 
-	params := map[string]interface{}{
-		"limit":  limit,
-		"viewer": viewer,
+	params := map[string]interface{}{}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if viewer != "" {
+		params["viewer"] = viewer
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.getTrendingTopics", params, nil, &out); err != nil {
 		return nil, err

api/bsky/unspeccedgetTrends.go

···
 func UnspeccedGetTrends(ctx context.Context, c *xrpc.Client, limit int64) (*UnspeccedGetTrends_Output, error) {
 	var out UnspeccedGetTrends_Output
 
-	params := map[string]interface{}{
-		"limit": limit,
+	params := map[string]interface{}{}
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.getTrends", params, nil, &out); err != nil {
 		return nil, err

api/bsky/unspeccedgetTrendsSkeleton.go

···
 func UnspeccedGetTrendsSkeleton(ctx context.Context, c *xrpc.Client, limit int64, viewer string) (*UnspeccedGetTrendsSkeleton_Output, error) {
 	var out UnspeccedGetTrendsSkeleton_Output
 
-	params := map[string]interface{}{
-		"limit":  limit,
-		"viewer": viewer,
+	params := map[string]interface{}{}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if viewer != "" {
+		params["viewer"] = viewer
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.getTrendsSkeleton", params, nil, &out); err != nil {
 		return nil, err

api/bsky/unspeccedsearchActorsSkeleton.go

···
 func UnspeccedSearchActorsSkeleton(ctx context.Context, c *xrpc.Client, cursor string, limit int64, q string, typeahead bool, viewer string) (*UnspeccedSearchActorsSkeleton_Output, error) {
 	var out UnspeccedSearchActorsSkeleton_Output
 
-	params := map[string]interface{}{
-		"cursor":    cursor,
-		"limit":     limit,
-		"q":         q,
-		"typeahead": typeahead,
-		"viewer":    viewer,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	params["q"] = q
+	if typeahead {
+		params["typeahead"] = typeahead
+	}
+	if viewer != "" {
+		params["viewer"] = viewer
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.searchActorsSkeleton", params, nil, &out); err != nil {
 		return nil, err

api/bsky/unspeccedsearchPostsSkeleton.go

···
 func UnspeccedSearchPostsSkeleton(ctx context.Context, c *xrpc.Client, author string, cursor string, domain string, lang string, limit int64, mentions string, q string, since string, sort string, tag []string, until string, url string, viewer string) (*UnspeccedSearchPostsSkeleton_Output, error) {
 	var out UnspeccedSearchPostsSkeleton_Output
 
-	params := map[string]interface{}{
-		"author":   author,
-		"cursor":   cursor,
-		"domain":   domain,
-		"lang":     lang,
-		"limit":    limit,
-		"mentions": mentions,
-		"q":        q,
-		"since":    since,
-		"sort":     sort,
-		"tag":      tag,
-		"until":    until,
-		"url":      url,
-		"viewer":   viewer,
+	params := map[string]interface{}{}
+	if author != "" {
+		params["author"] = author
+	}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if domain != "" {
+		params["domain"] = domain
+	}
+	if lang != "" {
+		params["lang"] = lang
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if mentions != "" {
+		params["mentions"] = mentions
+	}
+	params["q"] = q
+	if since != "" {
+		params["since"] = since
+	}
+	if sort != "" {
+		params["sort"] = sort
+	}
+	if len(tag) != 0 {
+		params["tag"] = tag
+	}
+	if until != "" {
+		params["until"] = until
+	}
+	if url != "" {
+		params["url"] = url
+	}
+	if viewer != "" {
+		params["viewer"] = viewer
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.searchPostsSkeleton", params, nil, &out); err != nil {
 		return nil, err

api/bsky/unspeccedsearchStarterPacksSkeleton.go

···
 func UnspeccedSearchStarterPacksSkeleton(ctx context.Context, c *xrpc.Client, cursor string, limit int64, q string, viewer string) (*UnspeccedSearchStarterPacksSkeleton_Output, error) {
 	var out UnspeccedSearchStarterPacksSkeleton_Output
 
-	params := map[string]interface{}{
-		"cursor": cursor,
-		"limit":  limit,
-		"q":      q,
-		"viewer": viewer,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	params["q"] = q
+	if viewer != "" {
+		params["viewer"] = viewer
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.searchStarterPacksSkeleton", params, nil, &out); err != nil {
 		return nil, err

api/bsky/videogetJobStatus.go

···
 func VideoGetJobStatus(ctx context.Context, c *xrpc.Client, jobId string) (*VideoGetJobStatus_Output, error) {
 	var out VideoGetJobStatus_Output
 
-	params := map[string]interface{}{
-		"jobId": jobId,
-	}
+	params := map[string]interface{}{}
+	params["jobId"] = jobId
 	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.video.getJobStatus", params, nil, &out); err != nil {
 		return nil, err
 	}

api/chat/convogetConvo.go

···
 func ConvoGetConvo(ctx context.Context, c *xrpc.Client, convoId string) (*ConvoGetConvo_Output, error) {
 	var out ConvoGetConvo_Output
 
-	params := map[string]interface{}{
-		"convoId": convoId,
-	}
+	params := map[string]interface{}{}
+	params["convoId"] = convoId
 	if err := c.Do(ctx, xrpc.Query, "", "chat.bsky.convo.getConvo", params, nil, &out); err != nil {
 		return nil, err
 	}

api/chat/convogetConvoAvailability.go

···
 func ConvoGetConvoAvailability(ctx context.Context, c *xrpc.Client, members []string) (*ConvoGetConvoAvailability_Output, error) {
 	var out ConvoGetConvoAvailability_Output
 
-	params := map[string]interface{}{
-		"members": members,
-	}
+	params := map[string]interface{}{}
+	params["members"] = members
 	if err := c.Do(ctx, xrpc.Query, "", "chat.bsky.convo.getConvoAvailability", params, nil, &out); err != nil {
 		return nil, err
 	}

api/chat/convogetConvoForMembers.go

···
 func ConvoGetConvoForMembers(ctx context.Context, c *xrpc.Client, members []string) (*ConvoGetConvoForMembers_Output, error) {
 	var out ConvoGetConvoForMembers_Output
 
-	params := map[string]interface{}{
-		"members": members,
-	}
+	params := map[string]interface{}{}
+	params["members"] = members
 	if err := c.Do(ctx, xrpc.Query, "", "chat.bsky.convo.getConvoForMembers", params, nil, &out); err != nil {
 		return nil, err
 	}

api/chat/convogetLog.go

···
 func ConvoGetLog(ctx context.Context, c *xrpc.Client, cursor string) (*ConvoGetLog_Output, error) {
 	var out ConvoGetLog_Output
 
-	params := map[string]interface{}{
-		"cursor": cursor,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "chat.bsky.convo.getLog", params, nil, &out); err != nil {
 		return nil, err

api/chat/convogetMessages.go

···
 func ConvoGetMessages(ctx context.Context, c *xrpc.Client, convoId string, cursor string, limit int64) (*ConvoGetMessages_Output, error) {
 	var out ConvoGetMessages_Output
 
-	params := map[string]interface{}{
-		"convoId": convoId,
-		"cursor":  cursor,
-		"limit":   limit,
+	params := map[string]interface{}{}
+	params["convoId"] = convoId
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "chat.bsky.convo.getMessages", params, nil, &out); err != nil {
 		return nil, err

api/chat/convolistConvos.go

···
 func ConvoListConvos(ctx context.Context, c *xrpc.Client, cursor string, limit int64, readState string, status string) (*ConvoListConvos_Output, error) {
 	var out ConvoListConvos_Output
 
-	params := map[string]interface{}{
-		"cursor":    cursor,
-		"limit":     limit,
-		"readState": readState,
-		"status":    status,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if readState != "" {
+		params["readState"] = readState
+	}
+	if status != "" {
+		params["status"] = status
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "chat.bsky.convo.listConvos", params, nil, &out); err != nil {
 		return nil, err

api/chat/moderationgetActorMetadata.go

···
 func ModerationGetActorMetadata(ctx context.Context, c *xrpc.Client, actor string) (*ModerationGetActorMetadata_Output, error) {
 	var out ModerationGetActorMetadata_Output
 
-	params := map[string]interface{}{
-		"actor": actor,
-	}
+	params := map[string]interface{}{}
+	params["actor"] = actor
 	if err := c.Do(ctx, xrpc.Query, "", "chat.bsky.moderation.getActorMetadata", params, nil, &out); err != nil {
 		return nil, err
 	}

api/chat/moderationgetMessageContext.go

···
 func ModerationGetMessageContext(ctx context.Context, c *xrpc.Client, after int64, before int64, convoId string, messageId string) (*ModerationGetMessageContext_Output, error) {
 	var out ModerationGetMessageContext_Output
 
-	params := map[string]interface{}{
-		"after":     after,
-		"before":    before,
-		"convoId":   convoId,
-		"messageId": messageId,
+	params := map[string]interface{}{}
+	if after != 0 {
+		params["after"] = after
+	}
+	if before != 0 {
+		params["before"] = before
+	}
+	if convoId != "" {
+		params["convoId"] = convoId
 	}
+	params["messageId"] = messageId
 	if err := c.Do(ctx, xrpc.Query, "", "chat.bsky.moderation.getMessageContext", params, nil, &out); err != nil {
 		return nil, err
 	}

api/ozone/hostinggetAccountHistory.go

···
 func HostingGetAccountHistory(ctx context.Context, c *xrpc.Client, cursor string, did string, events []string, limit int64) (*HostingGetAccountHistory_Output, error) {
 	var out HostingGetAccountHistory_Output
 
-	params := map[string]interface{}{
-		"cursor": cursor,
-		"did":    did,
-		"events": events,
-		"limit":  limit,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	params["did"] = did
+	if len(events) != 0 {
+		params["events"] = events
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.hosting.getAccountHistory", params, nil, &out); err != nil {
 		return nil, err

api/ozone/moderationgetEvent.go

···
 func ModerationGetEvent(ctx context.Context, c *xrpc.Client, id int64) (*ModerationDefs_ModEventViewDetail, error) {
 	var out ModerationDefs_ModEventViewDetail
 
-	params := map[string]interface{}{
-		"id": id,
-	}
+	params := map[string]interface{}{}
+	params["id"] = id
 	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.moderation.getEvent", params, nil, &out); err != nil {
 		return nil, err
 	}

api/ozone/moderationgetRecord.go

···
 func ModerationGetRecord(ctx context.Context, c *xrpc.Client, cid string, uri string) (*ModerationDefs_RecordViewDetail, error) {
 	var out ModerationDefs_RecordViewDetail
 
-	params := map[string]interface{}{
-		"cid": cid,
-		"uri": uri,
+	params := map[string]interface{}{}
+	if cid != "" {
+		params["cid"] = cid
 	}
+	params["uri"] = uri
 	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.moderation.getRecord", params, nil, &out); err != nil {
 		return nil, err
 	}

api/ozone/moderationgetRecords.go

···
 func ModerationGetRecords(ctx context.Context, c *xrpc.Client, uris []string) (*ModerationGetRecords_Output, error) {
 	var out ModerationGetRecords_Output
 
-	params := map[string]interface{}{
-		"uris": uris,
-	}
+	params := map[string]interface{}{}
+	params["uris"] = uris
 	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.moderation.getRecords", params, nil, &out); err != nil {
 		return nil, err
 	}

api/ozone/moderationgetRepo.go

···
 func ModerationGetRepo(ctx context.Context, c *xrpc.Client, did string) (*ModerationDefs_RepoViewDetail, error) {
 	var out ModerationDefs_RepoViewDetail
 
-	params := map[string]interface{}{
-		"did": did,
-	}
+	params := map[string]interface{}{}
+	params["did"] = did
 	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.moderation.getRepo", params, nil, &out); err != nil {
 		return nil, err
 	}

api/ozone/moderationgetReporterStats.go

···
 func ModerationGetReporterStats(ctx context.Context, c *xrpc.Client, dids []string) (*ModerationGetReporterStats_Output, error) {
 	var out ModerationGetReporterStats_Output
 
-	params := map[string]interface{}{
-		"dids": dids,
-	}
+	params := map[string]interface{}{}
+	params["dids"] = dids
 	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.moderation.getReporterStats", params, nil, &out); err != nil {
 		return nil, err
 	}

api/ozone/moderationgetRepos.go

···
 func ModerationGetRepos(ctx context.Context, c *xrpc.Client, dids []string) (*ModerationGetRepos_Output, error) {
 	var out ModerationGetRepos_Output
 
-	params := map[string]interface{}{
-		"dids": dids,
-	}
+	params := map[string]interface{}{}
+	params["dids"] = dids
 	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.moderation.getRepos", params, nil, &out); err != nil {
 		return nil, err
 	}

api/ozone/moderationgetSubjects.go

···
 func ModerationGetSubjects(ctx context.Context, c *xrpc.Client, subjects []string) (*ModerationGetSubjects_Output, error) {
 	var out ModerationGetSubjects_Output
 
-	params := map[string]interface{}{
-		"subjects": subjects,
-	}
+	params := map[string]interface{}{}
+	params["subjects"] = subjects
 	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.moderation.getSubjects", params, nil, &out); err != nil {
 		return nil, err
 	}

api/ozone/moderationqueryEvents.go

···
 func ModerationQueryEvents(ctx context.Context, c *xrpc.Client, addedLabels []string, addedTags []string, collections []string, comment string, createdAfter string, createdBefore string, createdBy string, cursor string, hasComment bool, includeAllUserRecords bool, limit int64, policies []string, removedLabels []string, removedTags []string, reportTypes []string, sortDirection string, subject string, subjectType string, types []string) (*ModerationQueryEvents_Output, error) {
 	var out ModerationQueryEvents_Output
 
-	params := map[string]interface{}{
-		"addedLabels":           addedLabels,
-		"addedTags":             addedTags,
-		"collections":           collections,
-		"comment":               comment,
-		"createdAfter":          createdAfter,
-		"createdBefore":         createdBefore,
-		"createdBy":             createdBy,
-		"cursor":                cursor,
-		"hasComment":            hasComment,
-		"includeAllUserRecords": includeAllUserRecords,
-		"limit":                 limit,
-		"policies":              policies,
-		"removedLabels":         removedLabels,
-		"removedTags":           removedTags,
-		"reportTypes":           reportTypes,
-		"sortDirection":         sortDirection,
-		"subject":               subject,
-		"subjectType":           subjectType,
-		"types":                 types,
+	params := map[string]interface{}{}
+	if len(addedLabels) != 0 {
+		params["addedLabels"] = addedLabels
+	}
+	if len(addedTags) != 0 {
+		params["addedTags"] = addedTags
+	}
+	if len(collections) != 0 {
+		params["collections"] = collections
+	}
+	if comment != "" {
+		params["comment"] = comment
+	}
+	if createdAfter != "" {
+		params["createdAfter"] = createdAfter
+	}
+	if createdBefore != "" {
+		params["createdBefore"] = createdBefore
+	}
+	if createdBy != "" {
+		params["createdBy"] = createdBy
+	}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if hasComment {
+		params["hasComment"] = hasComment
+	}
+	if includeAllUserRecords {
+		params["includeAllUserRecords"] = includeAllUserRecords
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if len(policies) != 0 {
+		params["policies"] = policies
+	}
+	if len(removedLabels) != 0 {
+		params["removedLabels"] = removedLabels
+	}
+	if len(removedTags) != 0 {
+		params["removedTags"] = removedTags
+	}
+	if len(reportTypes) != 0 {
+		params["reportTypes"] = reportTypes
+	}
+	if sortDirection != "" {
+		params["sortDirection"] = sortDirection
+	}
+	if subject != "" {
+		params["subject"] = subject
+	}
+	if subjectType != "" {
+		params["subjectType"] = subjectType
+	}
+	if len(types) != 0 {
+		params["types"] = types
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.moderation.queryEvents", params, nil, &out); err != nil {
 		return nil, err

api/ozone/moderationqueryStatuses.go

···
 func ModerationQueryStatuses(ctx context.Context, c *xrpc.Client, appealed bool, collections []string, comment string, cursor string, excludeTags []string, hostingDeletedAfter string, hostingDeletedBefore string, hostingStatuses []string, hostingUpdatedAfter string, hostingUpdatedBefore string, ignoreSubjects []string, includeAllUserRecords bool, includeMuted bool, lastReviewedBy string, limit int64, minAccountSuspendCount int64, minPriorityScore int64, minReportedRecordsCount int64, minTakendownRecordsCount int64, onlyMuted bool, queueCount int64, queueIndex int64, queueSeed string, reportedAfter string, reportedBefore string, reviewState string, reviewedAfter string, reviewedBefore string, sortDirection string, sortField string, subject string, subjectType string, tags []string, takendown bool) (*ModerationQueryStatuses_Output, error) {
 	var out ModerationQueryStatuses_Output
 
-	params := map[string]interface{}{
-		"appealed":                 appealed,
-		"collections":              collections,
-		"comment":                  comment,
-		"cursor":                   cursor,
-		"excludeTags":              excludeTags,
-		"hostingDeletedAfter":      hostingDeletedAfter,
-		"hostingDeletedBefore":     hostingDeletedBefore,
-		"hostingStatuses":          hostingStatuses,
-		"hostingUpdatedAfter":      hostingUpdatedAfter,
-		"hostingUpdatedBefore":     hostingUpdatedBefore,
-		"ignoreSubjects":           ignoreSubjects,
-		"includeAllUserRecords":    includeAllUserRecords,
-		"includeMuted":             includeMuted,
-		"lastReviewedBy":           lastReviewedBy,
-		"limit":                    limit,
-		"minAccountSuspendCount":   minAccountSuspendCount,
-		"minPriorityScore":         minPriorityScore,
-		"minReportedRecordsCount":  minReportedRecordsCount,
-		"minTakendownRecordsCount": minTakendownRecordsCount,
-		"onlyMuted":                onlyMuted,
-		"queueCount":               queueCount,
-		"queueIndex":               queueIndex,
-		"queueSeed":                queueSeed,
-		"reportedAfter":            reportedAfter,
-		"reportedBefore":           reportedBefore,
-		"reviewState":              reviewState,
-		"reviewedAfter":            reviewedAfter,
-		"reviewedBefore":           reviewedBefore,
-		"sortDirection":            sortDirection,
-		"sortField":                sortField,
-		"subject":                  subject,
-		"subjectType":              subjectType,
-		"tags":                     tags,
-		"takendown":                takendown,
+	params := map[string]interface{}{}
+	if appealed {
+		params["appealed"] = appealed
+	}
+	if len(collections) != 0 {
+		params["collections"] = collections
+	}
+	if comment != "" {
+		params["comment"] = comment
+	}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if len(excludeTags) != 0 {
+		params["excludeTags"] = excludeTags
+	}
+	if hostingDeletedAfter != "" {
+		params["hostingDeletedAfter"] = hostingDeletedAfter
+	}
+	if hostingDeletedBefore != "" {
+		params["hostingDeletedBefore"] = hostingDeletedBefore
+	}
+	if len(hostingStatuses) != 0 {
+		params["hostingStatuses"] = hostingStatuses
+	}
+	if hostingUpdatedAfter != "" {
+		params["hostingUpdatedAfter"] = hostingUpdatedAfter
+	}
+	if hostingUpdatedBefore != "" {
+		params["hostingUpdatedBefore"] = hostingUpdatedBefore
+	}
+	if len(ignoreSubjects) != 0 {
+		params["ignoreSubjects"] = ignoreSubjects
+	}
+	if includeAllUserRecords {
+		params["includeAllUserRecords"] = includeAllUserRecords
+	}
+	if includeMuted {
+		params["includeMuted"] = includeMuted
+	}
+	if lastReviewedBy != "" {
+		params["lastReviewedBy"] = lastReviewedBy
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if minAccountSuspendCount != 0 {
+		params["minAccountSuspendCount"] = minAccountSuspendCount
+	}
+	if minPriorityScore != 0 {
+		params["minPriorityScore"] = minPriorityScore
+	}
+	if minReportedRecordsCount != 0 {
+		params["minReportedRecordsCount"] = minReportedRecordsCount
+	}
+	if minTakendownRecordsCount != 0 {
+		params["minTakendownRecordsCount"] = minTakendownRecordsCount
+	}
+	if onlyMuted {
+		params["onlyMuted"] = onlyMuted
+	}
+	if queueCount != 0 {
+		params["queueCount"] = queueCount
+	}
+	if queueIndex != 0 {
+		params["queueIndex"] = queueIndex
+	}
+	if queueSeed != "" {
+		params["queueSeed"] = queueSeed
+	}
+	if reportedAfter != "" {
+		params["reportedAfter"] = reportedAfter
+	}
+	if reportedBefore != "" {
+		params["reportedBefore"] = reportedBefore
+	}
+	if reviewState != "" {
+		params["reviewState"] = reviewState
+	}
+	if reviewedAfter != "" {
+		params["reviewedAfter"] = reviewedAfter
+	}
+	if reviewedBefore != "" {
+		params["reviewedBefore"] = reviewedBefore
+	}
+	if sortDirection != "" {
+		params["sortDirection"] = sortDirection
+	}
+	if sortField != "" {
+		params["sortField"] = sortField
+	}
+	if subject != "" {
+		params["subject"] = subject
+	}
+	if subjectType != "" {
+		params["subjectType"] = subjectType
+	}
+	if len(tags) != 0 {
+		params["tags"] = tags
+	}
+	if takendown {
+		params["takendown"] = takendown
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.moderation.queryStatuses", params, nil, &out); err != nil {
 		return nil, err

api/ozone/moderationsearchRepos.go

···
 func ModerationSearchRepos(ctx context.Context, c *xrpc.Client, cursor string, limit int64, q string, term string) (*ModerationSearchRepos_Output, error) {
 	var out ModerationSearchRepos_Output
 
-	params := map[string]interface{}{
-		"cursor": cursor,
-		"limit":  limit,
-		"q":      q,
-		"term":   term,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if q != "" {
+		params["q"] = q
+	}
+	if term != "" {
+		params["term"] = term
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.moderation.searchRepos", params, nil, &out); err != nil {
 		return nil, err

api/ozone/setgetValues.go

···
 func SetGetValues(ctx context.Context, c *xrpc.Client, cursor string, limit int64, name string) (*SetGetValues_Output, error) {
 	var out SetGetValues_Output
 
-	params := map[string]interface{}{
-		"cursor": cursor,
-		"limit":  limit,
-		"name":   name,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
+	params["name"] = name
 	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.set.getValues", params, nil, &out); err != nil {
 		return nil, err
 	}

api/ozone/setquerySets.go

···
 func SetQuerySets(ctx context.Context, c *xrpc.Client, cursor string, limit int64, namePrefix string, sortBy string, sortDirection string) (*SetQuerySets_Output, error) {
 	var out SetQuerySets_Output
 
-	params := map[string]interface{}{
-		"cursor":        cursor,
-		"limit":         limit,
-		"namePrefix":    namePrefix,
-		"sortBy":        sortBy,
-		"sortDirection": sortDirection,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if namePrefix != "" {
+		params["namePrefix"] = namePrefix
+	}
+	if sortBy != "" {
+		params["sortBy"] = sortBy
+	}
+	if sortDirection != "" {
+		params["sortDirection"] = sortDirection
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.set.querySets", params, nil, &out); err != nil {
 		return nil, err

api/ozone/settinglistOptions.go

···
 func SettingListOptions(ctx context.Context, c *xrpc.Client, cursor string, keys []string, limit int64, prefix string, scope string) (*SettingListOptions_Output, error) {
 	var out SettingListOptions_Output
 
-	params := map[string]interface{}{
-		"cursor": cursor,
-		"keys":   keys,
-		"limit":  limit,
-		"prefix": prefix,
-		"scope":  scope,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if len(keys) != 0 {
+		params["keys"] = keys
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if prefix != "" {
+		params["prefix"] = prefix
+	}
+	if scope != "" {
+		params["scope"] = scope
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.setting.listOptions", params, nil, &out); err != nil {
 		return nil, err

api/ozone/signaturefindCorrelation.go

···
 func SignatureFindCorrelation(ctx context.Context, c *xrpc.Client, dids []string) (*SignatureFindCorrelation_Output, error) {
 	var out SignatureFindCorrelation_Output
 
-	params := map[string]interface{}{
-		"dids": dids,
-	}
+	params := map[string]interface{}{}
+	params["dids"] = dids
 	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.signature.findCorrelation", params, nil, &out); err != nil {
 		return nil, err
 	}

api/ozone/signaturefindRelatedAccounts.go

···
 func SignatureFindRelatedAccounts(ctx context.Context, c *xrpc.Client, cursor string, did string, limit int64) (*SignatureFindRelatedAccounts_Output, error) {
 	var out SignatureFindRelatedAccounts_Output
 
-	params := map[string]interface{}{
-		"cursor": cursor,
-		"did":    did,
-		"limit":  limit,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	params["did"] = did
+	if limit != 0 {
+		params["limit"] = limit
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.signature.findRelatedAccounts", params, nil, &out); err != nil {
 		return nil, err

api/ozone/signaturesearchAccounts.go

···
 func SignatureSearchAccounts(ctx context.Context, c *xrpc.Client, cursor string, limit int64, values []string) (*SignatureSearchAccounts_Output, error) {
 	var out SignatureSearchAccounts_Output
 
-	params := map[string]interface{}{
-		"cursor": cursor,
-		"limit":  limit,
-		"values": values,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if limit != 0 {
+		params["limit"] = limit
 	}
+	params["values"] = values
 	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.signature.searchAccounts", params, nil, &out); err != nil {
 		return nil, err
 	}

api/ozone/teamlistMembers.go

···
 func TeamListMembers(ctx context.Context, c *xrpc.Client, cursor string, disabled bool, limit int64, q string, roles []string) (*TeamListMembers_Output, error) {
 	var out TeamListMembers_Output
 
-	params := map[string]interface{}{
-		"cursor":   cursor,
-		"disabled": disabled,
-		"limit":    limit,
-		"q":        q,
-		"roles":    roles,
+	params := map[string]interface{}{}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if disabled {
+		params["disabled"] = disabled
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if q != "" {
+		params["q"] = q
+	}
+	if len(roles) != 0 {
+		params["roles"] = roles
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.team.listMembers", params, nil, &out); err != nil {
 		return nil, err

api/ozone/verificationlistVerifications.go

···
 func VerificationListVerifications(ctx context.Context, c *xrpc.Client, createdAfter string, createdBefore string, cursor string, isRevoked bool, issuers []string, limit int64, sortDirection string, subjects []string) (*VerificationListVerifications_Output, error) {
 	var out VerificationListVerifications_Output
 
-	params := map[string]interface{}{
-		"createdAfter":  createdAfter,
-		"createdBefore": createdBefore,
-		"cursor":        cursor,
-		"isRevoked":     isRevoked,
-		"issuers":       issuers,
-		"limit":         limit,
-		"sortDirection": sortDirection,
-		"subjects":      subjects,
+	params := map[string]interface{}{}
+	if createdAfter != "" {
+		params["createdAfter"] = createdAfter
+	}
+	if createdBefore != "" {
+		params["createdBefore"] = createdBefore
+	}
+	if cursor != "" {
+		params["cursor"] = cursor
+	}
+	if isRevoked {
+		params["isRevoked"] = isRevoked
+	}
+	if len(issuers) != 0 {
+		params["issuers"] = issuers
+	}
+	if limit != 0 {
+		params["limit"] = limit
+	}
+	if sortDirection != "" {
+		params["sortDirection"] = sortDirection
+	}
+	if len(subjects) != 0 {
+		params["subjects"] = subjects
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.verification.listVerifications", params, nil, &out); err != nil {
 		return nil, err

lex/type_schema.go

···
 import (
 	"fmt"
 	"io"
+	"slices"
 	"strings"
 )
 
···
 	queryparams := "nil"
 	if s.Parameters != nil {
 		queryparams = "params"
-		pf(`
-	params := map[string]interface{}{
-`)
+		pf("\n\tparams := map[string]interface{}{}\n")
 		if err := orderedMapIter(s.Parameters.Properties, func(name string, t *TypeSchema) error {
-			pf(`"%s": %s,
-`, name, name)
+			if slices.Contains(s.Parameters.Required, name) || slices.Contains(s.Parameters.Nullable, name) {
+				pf("params[\"%s\"] = %s\n", name, name)
+			} else {
+				// if parameter isn't required, only include conditionally
+				switch t.Type {
+				case "integer":
+					pf("if %s != 0 { params[\"%s\"] = %s }\n", name, name, name)
+				case "string":
+					pf("if %s != \"\" { params[\"%s\"] = %s }\n", name, name, name)
+				case "array":
+					pf("if len(%s) != 0 { params[\"%s\"] = %s }\n", name, name, name)
+				case "boolean":
+					pf("if %s { params[\"%s\"] = %s }\n", name, name, name)
+				default:
+					return fmt.Errorf("unhandled query param type: %s", t.Type)
+				}
+			}
 			return nil
 		}); err != nil {
 			return err
 		}
-		pf("}\n")
 	}
 
 	var reqtype string