update codegen with LexClient change

api/atproto/admindeleteAccount.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // AdminDeleteAccount_Input is the input argument to a com.atproto.admin.deleteAccount call.
···
 }
 
 // AdminDeleteAccount calls the XRPC method "com.atproto.admin.deleteAccount".
-func AdminDeleteAccount(ctx context.Context, c *xrpc.Client, input *AdminDeleteAccount_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.admin.deleteAccount", nil, input, nil); err != nil {
+func AdminDeleteAccount(ctx context.Context, c util.LexClient, input *AdminDeleteAccount_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.admin.deleteAccount", nil, input, nil); err != nil {
 		return err
 	}
 

api/atproto/admindisableAccountInvites.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // AdminDisableAccountInvites_Input is the input argument to a com.atproto.admin.disableAccountInvites call.
···
 }
 
 // AdminDisableAccountInvites calls the XRPC method "com.atproto.admin.disableAccountInvites".
-func AdminDisableAccountInvites(ctx context.Context, c *xrpc.Client, input *AdminDisableAccountInvites_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.admin.disableAccountInvites", nil, input, nil); err != nil {
+func AdminDisableAccountInvites(ctx context.Context, c util.LexClient, input *AdminDisableAccountInvites_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.admin.disableAccountInvites", nil, input, nil); err != nil {
 		return err
 	}
 

api/atproto/admindisableInviteCodes.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // AdminDisableInviteCodes_Input is the input argument to a com.atproto.admin.disableInviteCodes call.
···
 }
 
 // AdminDisableInviteCodes calls the XRPC method "com.atproto.admin.disableInviteCodes".
-func AdminDisableInviteCodes(ctx context.Context, c *xrpc.Client, input *AdminDisableInviteCodes_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.admin.disableInviteCodes", nil, input, nil); err != nil {
+func AdminDisableInviteCodes(ctx context.Context, c util.LexClient, input *AdminDisableInviteCodes_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.admin.disableInviteCodes", nil, input, nil); err != nil {
 		return err
 	}
 

api/atproto/adminenableAccountInvites.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // AdminEnableAccountInvites_Input is the input argument to a com.atproto.admin.enableAccountInvites call.
···
 }
 
 // AdminEnableAccountInvites calls the XRPC method "com.atproto.admin.enableAccountInvites".
-func AdminEnableAccountInvites(ctx context.Context, c *xrpc.Client, input *AdminEnableAccountInvites_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.admin.enableAccountInvites", nil, input, nil); err != nil {
+func AdminEnableAccountInvites(ctx context.Context, c util.LexClient, input *AdminEnableAccountInvites_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.admin.enableAccountInvites", nil, input, nil); err != nil {
 		return err
 	}
 

api/atproto/admingetAccountInfo.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // AdminGetAccountInfo calls the XRPC method "com.atproto.admin.getAccountInfo".
-func AdminGetAccountInfo(ctx context.Context, c *xrpc.Client, did string) (*AdminDefs_AccountView, error) {
+func AdminGetAccountInfo(ctx context.Context, c util.LexClient, did string) (*AdminDefs_AccountView, error) {
 	var out AdminDefs_AccountView
 
 	params := map[string]interface{}{}
 	params["did"] = did
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.admin.getAccountInfo", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.admin.getAccountInfo", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/admingetAccountInfos.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // AdminGetAccountInfos_Output is the output of a com.atproto.admin.getAccountInfos call.
···
 }
 
 // AdminGetAccountInfos calls the XRPC method "com.atproto.admin.getAccountInfos".
-func AdminGetAccountInfos(ctx context.Context, c *xrpc.Client, dids []string) (*AdminGetAccountInfos_Output, error) {
+func AdminGetAccountInfos(ctx context.Context, c util.LexClient, dids []string) (*AdminGetAccountInfos_Output, error) {
 	var out AdminGetAccountInfos_Output
 
 	params := map[string]interface{}{}
 	params["dids"] = dids
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.admin.getAccountInfos", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.admin.getAccountInfos", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/admingetInviteCodes.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // AdminGetInviteCodes_Output is the output of a com.atproto.admin.getInviteCodes call.
···
 }
 
 // AdminGetInviteCodes calls the XRPC method "com.atproto.admin.getInviteCodes".
-func AdminGetInviteCodes(ctx context.Context, c *xrpc.Client, cursor string, limit int64, sort string) (*AdminGetInviteCodes_Output, error) {
+func AdminGetInviteCodes(ctx context.Context, c util.LexClient, cursor string, limit int64, sort string) (*AdminGetInviteCodes_Output, error) {
 	var out AdminGetInviteCodes_Output
 
 	params := map[string]interface{}{}
···
 	if sort != "" {
 		params["sort"] = sort
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.admin.getInviteCodes", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.admin.getInviteCodes", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/admingetSubjectStatus.go

···
 	"fmt"
 
 	"github.com/bluesky-social/indigo/lex/util"
-	"github.com/bluesky-social/indigo/xrpc"
 )
 
 // AdminGetSubjectStatus_Output is the output of a com.atproto.admin.getSubjectStatus call.
···
 }
 
 // AdminGetSubjectStatus calls the XRPC method "com.atproto.admin.getSubjectStatus".
-func AdminGetSubjectStatus(ctx context.Context, c *xrpc.Client, blob string, did string, uri string) (*AdminGetSubjectStatus_Output, error) {
+func AdminGetSubjectStatus(ctx context.Context, c util.LexClient, blob string, did string, uri string) (*AdminGetSubjectStatus_Output, error) {
 	var out AdminGetSubjectStatus_Output
 
 	params := map[string]interface{}{}
···
 	if uri != "" {
 		params["uri"] = uri
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.admin.getSubjectStatus", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.admin.getSubjectStatus", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/adminsearchAccounts.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // AdminSearchAccounts_Output is the output of a com.atproto.admin.searchAccounts call.
···
 }
 
 // AdminSearchAccounts calls the XRPC method "com.atproto.admin.searchAccounts".
-func AdminSearchAccounts(ctx context.Context, c *xrpc.Client, cursor string, email string, limit int64) (*AdminSearchAccounts_Output, error) {
+func AdminSearchAccounts(ctx context.Context, c util.LexClient, cursor string, email string, limit int64) (*AdminSearchAccounts_Output, error) {
 	var out AdminSearchAccounts_Output
 
 	params := map[string]interface{}{}
···
 	if limit != 0 {
 		params["limit"] = limit
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.admin.searchAccounts", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.admin.searchAccounts", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/adminsendEmail.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // AdminSendEmail_Input is the input argument to a com.atproto.admin.sendEmail call.
···
 }
 
 // AdminSendEmail calls the XRPC method "com.atproto.admin.sendEmail".
-func AdminSendEmail(ctx context.Context, c *xrpc.Client, input *AdminSendEmail_Input) (*AdminSendEmail_Output, error) {
+func AdminSendEmail(ctx context.Context, c util.LexClient, input *AdminSendEmail_Input) (*AdminSendEmail_Output, error) {
 	var out AdminSendEmail_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.admin.sendEmail", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.admin.sendEmail", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/adminupdateAccountEmail.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // AdminUpdateAccountEmail_Input is the input argument to a com.atproto.admin.updateAccountEmail call.
···
 }
 
 // AdminUpdateAccountEmail calls the XRPC method "com.atproto.admin.updateAccountEmail".
-func AdminUpdateAccountEmail(ctx context.Context, c *xrpc.Client, input *AdminUpdateAccountEmail_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.admin.updateAccountEmail", nil, input, nil); err != nil {
+func AdminUpdateAccountEmail(ctx context.Context, c util.LexClient, input *AdminUpdateAccountEmail_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.admin.updateAccountEmail", nil, input, nil); err != nil {
 		return err
 	}
 

api/atproto/adminupdateAccountHandle.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // AdminUpdateAccountHandle_Input is the input argument to a com.atproto.admin.updateAccountHandle call.
···
 }
 
 // AdminUpdateAccountHandle calls the XRPC method "com.atproto.admin.updateAccountHandle".
-func AdminUpdateAccountHandle(ctx context.Context, c *xrpc.Client, input *AdminUpdateAccountHandle_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.admin.updateAccountHandle", nil, input, nil); err != nil {
+func AdminUpdateAccountHandle(ctx context.Context, c util.LexClient, input *AdminUpdateAccountHandle_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.admin.updateAccountHandle", nil, input, nil); err != nil {
 		return err
 	}
 

api/atproto/adminupdateAccountPassword.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // AdminUpdateAccountPassword_Input is the input argument to a com.atproto.admin.updateAccountPassword call.
···
 }
 
 // AdminUpdateAccountPassword calls the XRPC method "com.atproto.admin.updateAccountPassword".
-func AdminUpdateAccountPassword(ctx context.Context, c *xrpc.Client, input *AdminUpdateAccountPassword_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.admin.updateAccountPassword", nil, input, nil); err != nil {
+func AdminUpdateAccountPassword(ctx context.Context, c util.LexClient, input *AdminUpdateAccountPassword_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.admin.updateAccountPassword", nil, input, nil); err != nil {
 		return err
 	}
 

api/atproto/adminupdateAccountSigningKey.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // AdminUpdateAccountSigningKey_Input is the input argument to a com.atproto.admin.updateAccountSigningKey call.
···
 }
 
 // AdminUpdateAccountSigningKey calls the XRPC method "com.atproto.admin.updateAccountSigningKey".
-func AdminUpdateAccountSigningKey(ctx context.Context, c *xrpc.Client, input *AdminUpdateAccountSigningKey_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.admin.updateAccountSigningKey", nil, input, nil); err != nil {
+func AdminUpdateAccountSigningKey(ctx context.Context, c util.LexClient, input *AdminUpdateAccountSigningKey_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.admin.updateAccountSigningKey", nil, input, nil); err != nil {
 		return err
 	}
 

api/atproto/adminupdateSubjectStatus.go

···
 	"fmt"
 
 	"github.com/bluesky-social/indigo/lex/util"
-	"github.com/bluesky-social/indigo/xrpc"
 )
 
 // AdminUpdateSubjectStatus_Input is the input argument to a com.atproto.admin.updateSubjectStatus call.
···
 }
 
 // AdminUpdateSubjectStatus calls the XRPC method "com.atproto.admin.updateSubjectStatus".
-func AdminUpdateSubjectStatus(ctx context.Context, c *xrpc.Client, input *AdminUpdateSubjectStatus_Input) (*AdminUpdateSubjectStatus_Output, error) {
+func AdminUpdateSubjectStatus(ctx context.Context, c util.LexClient, input *AdminUpdateSubjectStatus_Input) (*AdminUpdateSubjectStatus_Output, error) {
 	var out AdminUpdateSubjectStatus_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.admin.updateSubjectStatus", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.admin.updateSubjectStatus", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/identitygetRecommendedDidCredentials.go

···
 	"context"
 
 	"github.com/bluesky-social/indigo/lex/util"
-	"github.com/bluesky-social/indigo/xrpc"
 )
 
 // IdentityGetRecommendedDidCredentials_Output is the output of a com.atproto.identity.getRecommendedDidCredentials call.
···
 }
 
 // IdentityGetRecommendedDidCredentials calls the XRPC method "com.atproto.identity.getRecommendedDidCredentials".
-func IdentityGetRecommendedDidCredentials(ctx context.Context, c *xrpc.Client) (*IdentityGetRecommendedDidCredentials_Output, error) {
+func IdentityGetRecommendedDidCredentials(ctx context.Context, c util.LexClient) (*IdentityGetRecommendedDidCredentials_Output, error) {
 	var out IdentityGetRecommendedDidCredentials_Output
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.identity.getRecommendedDidCredentials", nil, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.identity.getRecommendedDidCredentials", nil, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/identityrefreshIdentity.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // IdentityRefreshIdentity_Input is the input argument to a com.atproto.identity.refreshIdentity call.
···
 }
 
 // IdentityRefreshIdentity calls the XRPC method "com.atproto.identity.refreshIdentity".
-func IdentityRefreshIdentity(ctx context.Context, c *xrpc.Client, input *IdentityRefreshIdentity_Input) (*IdentityDefs_IdentityInfo, error) {
+func IdentityRefreshIdentity(ctx context.Context, c util.LexClient, input *IdentityRefreshIdentity_Input) (*IdentityDefs_IdentityInfo, error) {
 	var out IdentityDefs_IdentityInfo
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.identity.refreshIdentity", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.identity.refreshIdentity", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/identityrequestPlcOperationSignature.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // IdentityRequestPlcOperationSignature calls the XRPC method "com.atproto.identity.requestPlcOperationSignature".
-func IdentityRequestPlcOperationSignature(ctx context.Context, c *xrpc.Client) error {
-	if err := c.Do(ctx, xrpc.Procedure, "", "com.atproto.identity.requestPlcOperationSignature", nil, nil, nil); err != nil {
+func IdentityRequestPlcOperationSignature(ctx context.Context, c util.LexClient) error {
+	if err := c.LexDo(ctx, util.Procedure, "", "com.atproto.identity.requestPlcOperationSignature", nil, nil, nil); err != nil {
 		return err
 	}
 

api/atproto/identityresolveDid.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // IdentityResolveDid_Output is the output of a com.atproto.identity.resolveDid call.
···
 // IdentityResolveDid calls the XRPC method "com.atproto.identity.resolveDid".
 //
 // did: DID to resolve.
-func IdentityResolveDid(ctx context.Context, c *xrpc.Client, did string) (*IdentityResolveDid_Output, error) {
+func IdentityResolveDid(ctx context.Context, c util.LexClient, did string) (*IdentityResolveDid_Output, error) {
 	var out IdentityResolveDid_Output
 
 	params := map[string]interface{}{}
 	params["did"] = did
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.identity.resolveDid", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.identity.resolveDid", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/identityresolveHandle.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // IdentityResolveHandle_Output is the output of a com.atproto.identity.resolveHandle call.
···
 // IdentityResolveHandle calls the XRPC method "com.atproto.identity.resolveHandle".
 //
 // handle: The handle to resolve.
-func IdentityResolveHandle(ctx context.Context, c *xrpc.Client, handle string) (*IdentityResolveHandle_Output, error) {
+func IdentityResolveHandle(ctx context.Context, c util.LexClient, handle string) (*IdentityResolveHandle_Output, error) {
 	var out IdentityResolveHandle_Output
 
 	params := map[string]interface{}{}
 	params["handle"] = handle
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.identity.resolveHandle", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.identity.resolveHandle", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/identityresolveIdentity.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // IdentityResolveIdentity calls the XRPC method "com.atproto.identity.resolveIdentity".
 //
 // identifier: Handle or DID to resolve.
-func IdentityResolveIdentity(ctx context.Context, c *xrpc.Client, identifier string) (*IdentityDefs_IdentityInfo, error) {
+func IdentityResolveIdentity(ctx context.Context, c util.LexClient, identifier string) (*IdentityDefs_IdentityInfo, error) {
 	var out IdentityDefs_IdentityInfo
 
 	params := map[string]interface{}{}
 	params["identifier"] = identifier
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.identity.resolveIdentity", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.identity.resolveIdentity", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/identitysignPlcOperation.go

···
 	"context"
 
 	"github.com/bluesky-social/indigo/lex/util"
-	"github.com/bluesky-social/indigo/xrpc"
 )
 
 // IdentitySignPlcOperation_Input is the input argument to a com.atproto.identity.signPlcOperation call.
···
 }
 
 // IdentitySignPlcOperation calls the XRPC method "com.atproto.identity.signPlcOperation".
-func IdentitySignPlcOperation(ctx context.Context, c *xrpc.Client, input *IdentitySignPlcOperation_Input) (*IdentitySignPlcOperation_Output, error) {
+func IdentitySignPlcOperation(ctx context.Context, c util.LexClient, input *IdentitySignPlcOperation_Input) (*IdentitySignPlcOperation_Output, error) {
 	var out IdentitySignPlcOperation_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.identity.signPlcOperation", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.identity.signPlcOperation", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/identitysubmitPlcOperation.go

···
 	"context"
 
 	"github.com/bluesky-social/indigo/lex/util"
-	"github.com/bluesky-social/indigo/xrpc"
 )
 
 // IdentitySubmitPlcOperation_Input is the input argument to a com.atproto.identity.submitPlcOperation call.
···
 }
 
 // IdentitySubmitPlcOperation calls the XRPC method "com.atproto.identity.submitPlcOperation".
-func IdentitySubmitPlcOperation(ctx context.Context, c *xrpc.Client, input *IdentitySubmitPlcOperation_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.identity.submitPlcOperation", nil, input, nil); err != nil {
+func IdentitySubmitPlcOperation(ctx context.Context, c util.LexClient, input *IdentitySubmitPlcOperation_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.identity.submitPlcOperation", nil, input, nil); err != nil {
 		return err
 	}
 

api/atproto/identityupdateHandle.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // IdentityUpdateHandle_Input is the input argument to a com.atproto.identity.updateHandle call.
···
 }
 
 // IdentityUpdateHandle calls the XRPC method "com.atproto.identity.updateHandle".
-func IdentityUpdateHandle(ctx context.Context, c *xrpc.Client, input *IdentityUpdateHandle_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.identity.updateHandle", nil, input, nil); err != nil {
+func IdentityUpdateHandle(ctx context.Context, c util.LexClient, input *IdentityUpdateHandle_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.identity.updateHandle", nil, input, nil); err != nil {
 		return err
 	}
 

api/atproto/labelqueryLabels.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // LabelQueryLabels_Output is the output of a com.atproto.label.queryLabels call.
···
 //
 // sources: Optional list of label sources (DIDs) to filter on.
 // uriPatterns: List of AT URI patterns to match (boolean 'OR'). Each may be a prefix (ending with '*'; will match inclusive of the string leading to '*'), or a full URI.
-func LabelQueryLabels(ctx context.Context, c *xrpc.Client, cursor string, limit int64, sources []string, uriPatterns []string) (*LabelQueryLabels_Output, error) {
+func LabelQueryLabels(ctx context.Context, c util.LexClient, cursor string, limit int64, sources []string, uriPatterns []string) (*LabelQueryLabels_Output, error) {
 	var out LabelQueryLabels_Output
 
 	params := map[string]interface{}{}
···
 		params["sources"] = sources
 	}
 	params["uriPatterns"] = uriPatterns
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.label.queryLabels", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.label.queryLabels", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/moderationcreateReport.go

···
 	"fmt"
 
 	"github.com/bluesky-social/indigo/lex/util"
-	"github.com/bluesky-social/indigo/xrpc"
 )
 
 // ModerationCreateReport_Input is the input argument to a com.atproto.moderation.createReport call.
···
 }
 
 // ModerationCreateReport calls the XRPC method "com.atproto.moderation.createReport".
-func ModerationCreateReport(ctx context.Context, c *xrpc.Client, input *ModerationCreateReport_Input) (*ModerationCreateReport_Output, error) {
+func ModerationCreateReport(ctx context.Context, c util.LexClient, input *ModerationCreateReport_Input) (*ModerationCreateReport_Output, error) {
 	var out ModerationCreateReport_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.moderation.createReport", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.moderation.createReport", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/repoapplyWrites.go

···
 	"fmt"
 
 	"github.com/bluesky-social/indigo/lex/util"
-	"github.com/bluesky-social/indigo/xrpc"
 )
 
 // RepoApplyWrites_Create is a "create" in the com.atproto.repo.applyWrites schema.
···
 }
 
 // RepoApplyWrites calls the XRPC method "com.atproto.repo.applyWrites".
-func RepoApplyWrites(ctx context.Context, c *xrpc.Client, input *RepoApplyWrites_Input) (*RepoApplyWrites_Output, error) {
+func RepoApplyWrites(ctx context.Context, c util.LexClient, input *RepoApplyWrites_Input) (*RepoApplyWrites_Output, error) {
 	var out RepoApplyWrites_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.repo.applyWrites", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.repo.applyWrites", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/repocreateRecord.go

···
 	"context"
 
 	"github.com/bluesky-social/indigo/lex/util"
-	"github.com/bluesky-social/indigo/xrpc"
 )
 
 // RepoCreateRecord_Input is the input argument to a com.atproto.repo.createRecord call.
···
 }
 
 // RepoCreateRecord calls the XRPC method "com.atproto.repo.createRecord".
-func RepoCreateRecord(ctx context.Context, c *xrpc.Client, input *RepoCreateRecord_Input) (*RepoCreateRecord_Output, error) {
+func RepoCreateRecord(ctx context.Context, c util.LexClient, input *RepoCreateRecord_Input) (*RepoCreateRecord_Output, error) {
 	var out RepoCreateRecord_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.repo.createRecord", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.repo.createRecord", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/repodeleteRecord.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // RepoDeleteRecord_Input is the input argument to a com.atproto.repo.deleteRecord call.
···
 }
 
 // RepoDeleteRecord calls the XRPC method "com.atproto.repo.deleteRecord".
-func RepoDeleteRecord(ctx context.Context, c *xrpc.Client, input *RepoDeleteRecord_Input) (*RepoDeleteRecord_Output, error) {
+func RepoDeleteRecord(ctx context.Context, c util.LexClient, input *RepoDeleteRecord_Input) (*RepoDeleteRecord_Output, error) {
 	var out RepoDeleteRecord_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.repo.deleteRecord", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.repo.deleteRecord", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/repodescribeRepo.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // RepoDescribeRepo_Output is the output of a com.atproto.repo.describeRepo call.
···
 // RepoDescribeRepo calls the XRPC method "com.atproto.repo.describeRepo".
 //
 // repo: The handle or DID of the repo.
-func RepoDescribeRepo(ctx context.Context, c *xrpc.Client, repo string) (*RepoDescribeRepo_Output, error) {
+func RepoDescribeRepo(ctx context.Context, c util.LexClient, repo string) (*RepoDescribeRepo_Output, error) {
 	var out RepoDescribeRepo_Output
 
 	params := map[string]interface{}{}
 	params["repo"] = repo
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.repo.describeRepo", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.repo.describeRepo", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/repogetRecord.go

···
 	"context"
 
 	"github.com/bluesky-social/indigo/lex/util"
-	"github.com/bluesky-social/indigo/xrpc"
 )
 
 // RepoGetRecord_Output is the output of a com.atproto.repo.getRecord call.
···
 // collection: The NSID of the record collection.
 // repo: The handle or DID of the repo.
 // rkey: The Record Key.
-func RepoGetRecord(ctx context.Context, c *xrpc.Client, cid string, collection string, repo string, rkey string) (*RepoGetRecord_Output, error) {
+func RepoGetRecord(ctx context.Context, c util.LexClient, cid string, collection string, repo string, rkey string) (*RepoGetRecord_Output, error) {
 	var out RepoGetRecord_Output
 
 	params := map[string]interface{}{}
···
 	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 {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.repo.getRecord", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/repoimportRepo.go

···
 	"context"
 	"io"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // RepoImportRepo calls the XRPC method "com.atproto.repo.importRepo".
-func RepoImportRepo(ctx context.Context, c *xrpc.Client, input io.Reader) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/vnd.ipld.car", "com.atproto.repo.importRepo", nil, input, nil); err != nil {
+func RepoImportRepo(ctx context.Context, c util.LexClient, input io.Reader) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/vnd.ipld.car", "com.atproto.repo.importRepo", nil, input, nil); err != nil {
 		return err
 	}
 

api/atproto/repolistMissingBlobs.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // RepoListMissingBlobs_Output is the output of a com.atproto.repo.listMissingBlobs call.
···
 }
 
 // RepoListMissingBlobs calls the XRPC method "com.atproto.repo.listMissingBlobs".
-func RepoListMissingBlobs(ctx context.Context, c *xrpc.Client, cursor string, limit int64) (*RepoListMissingBlobs_Output, error) {
+func RepoListMissingBlobs(ctx context.Context, c util.LexClient, cursor string, limit int64) (*RepoListMissingBlobs_Output, error) {
 	var out RepoListMissingBlobs_Output
 
 	params := map[string]interface{}{}
···
 	if limit != 0 {
 		params["limit"] = limit
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.repo.listMissingBlobs", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.repo.listMissingBlobs", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/repolistRecords.go

···
 	"context"
 
 	"github.com/bluesky-social/indigo/lex/util"
-	"github.com/bluesky-social/indigo/xrpc"
 )
 
 // RepoListRecords_Output is the output of a com.atproto.repo.listRecords call.
···
 // limit: The number of records to return.
 // repo: The handle or DID of the repo.
 // reverse: Flag to reverse the order of the returned records.
-func RepoListRecords(ctx context.Context, c *xrpc.Client, collection string, cursor string, limit int64, repo string, reverse bool) (*RepoListRecords_Output, error) {
+func RepoListRecords(ctx context.Context, c util.LexClient, collection string, cursor string, limit int64, repo string, reverse bool) (*RepoListRecords_Output, error) {
 	var out RepoListRecords_Output
 
 	params := map[string]interface{}{}
···
 	if reverse {
 		params["reverse"] = reverse
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.repo.listRecords", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.repo.listRecords", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/repoputRecord.go

···
 	"context"
 
 	"github.com/bluesky-social/indigo/lex/util"
-	"github.com/bluesky-social/indigo/xrpc"
 )
 
 // RepoPutRecord_Input is the input argument to a com.atproto.repo.putRecord call.
···
 }
 
 // RepoPutRecord calls the XRPC method "com.atproto.repo.putRecord".
-func RepoPutRecord(ctx context.Context, c *xrpc.Client, input *RepoPutRecord_Input) (*RepoPutRecord_Output, error) {
+func RepoPutRecord(ctx context.Context, c util.LexClient, input *RepoPutRecord_Input) (*RepoPutRecord_Output, error) {
 	var out RepoPutRecord_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.repo.putRecord", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.repo.putRecord", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/repouploadBlob.go

···
 	"io"
 
 	"github.com/bluesky-social/indigo/lex/util"
-	"github.com/bluesky-social/indigo/xrpc"
 )
 
 // RepoUploadBlob_Output is the output of a com.atproto.repo.uploadBlob call.
···
 }
 
 // RepoUploadBlob calls the XRPC method "com.atproto.repo.uploadBlob".
-func RepoUploadBlob(ctx context.Context, c *xrpc.Client, input io.Reader) (*RepoUploadBlob_Output, error) {
+func RepoUploadBlob(ctx context.Context, c util.LexClient, input io.Reader) (*RepoUploadBlob_Output, error) {
 	var out RepoUploadBlob_Output
-	if err := c.Do(ctx, xrpc.Procedure, "*/*", "com.atproto.repo.uploadBlob", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "*/*", "com.atproto.repo.uploadBlob", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/serveractivateAccount.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ServerActivateAccount calls the XRPC method "com.atproto.server.activateAccount".
-func ServerActivateAccount(ctx context.Context, c *xrpc.Client) error {
-	if err := c.Do(ctx, xrpc.Procedure, "", "com.atproto.server.activateAccount", nil, nil, nil); err != nil {
+func ServerActivateAccount(ctx context.Context, c util.LexClient) error {
+	if err := c.LexDo(ctx, util.Procedure, "", "com.atproto.server.activateAccount", nil, nil, nil); err != nil {
 		return err
 	}
 

api/atproto/servercheckAccountStatus.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ServerCheckAccountStatus_Output is the output of a com.atproto.server.checkAccountStatus call.
···
 }
 
 // ServerCheckAccountStatus calls the XRPC method "com.atproto.server.checkAccountStatus".
-func ServerCheckAccountStatus(ctx context.Context, c *xrpc.Client) (*ServerCheckAccountStatus_Output, error) {
+func ServerCheckAccountStatus(ctx context.Context, c util.LexClient) (*ServerCheckAccountStatus_Output, error) {
 	var out ServerCheckAccountStatus_Output
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.server.checkAccountStatus", nil, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.server.checkAccountStatus", nil, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/serverconfirmEmail.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ServerConfirmEmail_Input is the input argument to a com.atproto.server.confirmEmail call.
···
 }
 
 // ServerConfirmEmail calls the XRPC method "com.atproto.server.confirmEmail".
-func ServerConfirmEmail(ctx context.Context, c *xrpc.Client, input *ServerConfirmEmail_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.server.confirmEmail", nil, input, nil); err != nil {
+func ServerConfirmEmail(ctx context.Context, c util.LexClient, input *ServerConfirmEmail_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.server.confirmEmail", nil, input, nil); err != nil {
 		return err
 	}
 

api/atproto/servercreateAccount.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ServerCreateAccount_Input is the input argument to a com.atproto.server.createAccount call.
···
 }
 
 // ServerCreateAccount calls the XRPC method "com.atproto.server.createAccount".
-func ServerCreateAccount(ctx context.Context, c *xrpc.Client, input *ServerCreateAccount_Input) (*ServerCreateAccount_Output, error) {
+func ServerCreateAccount(ctx context.Context, c util.LexClient, input *ServerCreateAccount_Input) (*ServerCreateAccount_Output, error) {
 	var out ServerCreateAccount_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.server.createAccount", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.server.createAccount", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/servercreateAppPassword.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ServerCreateAppPassword_AppPassword is a "appPassword" in the com.atproto.server.createAppPassword schema.
···
 }
 
 // ServerCreateAppPassword calls the XRPC method "com.atproto.server.createAppPassword".
-func ServerCreateAppPassword(ctx context.Context, c *xrpc.Client, input *ServerCreateAppPassword_Input) (*ServerCreateAppPassword_AppPassword, error) {
+func ServerCreateAppPassword(ctx context.Context, c util.LexClient, input *ServerCreateAppPassword_Input) (*ServerCreateAppPassword_AppPassword, error) {
 	var out ServerCreateAppPassword_AppPassword
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.server.createAppPassword", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.server.createAppPassword", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/servercreateInviteCode.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ServerCreateInviteCode_Input is the input argument to a com.atproto.server.createInviteCode call.
···
 }
 
 // ServerCreateInviteCode calls the XRPC method "com.atproto.server.createInviteCode".
-func ServerCreateInviteCode(ctx context.Context, c *xrpc.Client, input *ServerCreateInviteCode_Input) (*ServerCreateInviteCode_Output, error) {
+func ServerCreateInviteCode(ctx context.Context, c util.LexClient, input *ServerCreateInviteCode_Input) (*ServerCreateInviteCode_Output, error) {
 	var out ServerCreateInviteCode_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.server.createInviteCode", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.server.createInviteCode", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/servercreateInviteCodes.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ServerCreateInviteCodes_AccountCodes is a "accountCodes" in the com.atproto.server.createInviteCodes schema.
···
 }
 
 // ServerCreateInviteCodes calls the XRPC method "com.atproto.server.createInviteCodes".
-func ServerCreateInviteCodes(ctx context.Context, c *xrpc.Client, input *ServerCreateInviteCodes_Input) (*ServerCreateInviteCodes_Output, error) {
+func ServerCreateInviteCodes(ctx context.Context, c util.LexClient, input *ServerCreateInviteCodes_Input) (*ServerCreateInviteCodes_Output, error) {
 	var out ServerCreateInviteCodes_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.server.createInviteCodes", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.server.createInviteCodes", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/servercreateSession.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ServerCreateSession_Input is the input argument to a com.atproto.server.createSession call.
···
 }
 
 // ServerCreateSession calls the XRPC method "com.atproto.server.createSession".
-func ServerCreateSession(ctx context.Context, c *xrpc.Client, input *ServerCreateSession_Input) (*ServerCreateSession_Output, error) {
+func ServerCreateSession(ctx context.Context, c util.LexClient, input *ServerCreateSession_Input) (*ServerCreateSession_Output, error) {
 	var out ServerCreateSession_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.server.createSession", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.server.createSession", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/serverdeactivateAccount.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ServerDeactivateAccount_Input is the input argument to a com.atproto.server.deactivateAccount call.
···
 }
 
 // ServerDeactivateAccount calls the XRPC method "com.atproto.server.deactivateAccount".
-func ServerDeactivateAccount(ctx context.Context, c *xrpc.Client, input *ServerDeactivateAccount_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.server.deactivateAccount", nil, input, nil); err != nil {
+func ServerDeactivateAccount(ctx context.Context, c util.LexClient, input *ServerDeactivateAccount_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.server.deactivateAccount", nil, input, nil); err != nil {
 		return err
 	}
 

api/atproto/serverdeleteAccount.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ServerDeleteAccount_Input is the input argument to a com.atproto.server.deleteAccount call.
···
 }
 
 // ServerDeleteAccount calls the XRPC method "com.atproto.server.deleteAccount".
-func ServerDeleteAccount(ctx context.Context, c *xrpc.Client, input *ServerDeleteAccount_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.server.deleteAccount", nil, input, nil); err != nil {
+func ServerDeleteAccount(ctx context.Context, c util.LexClient, input *ServerDeleteAccount_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.server.deleteAccount", nil, input, nil); err != nil {
 		return err
 	}
 

api/atproto/serverdeleteSession.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ServerDeleteSession calls the XRPC method "com.atproto.server.deleteSession".
-func ServerDeleteSession(ctx context.Context, c *xrpc.Client) error {
-	if err := c.Do(ctx, xrpc.Procedure, "", "com.atproto.server.deleteSession", nil, nil, nil); err != nil {
+func ServerDeleteSession(ctx context.Context, c util.LexClient) error {
+	if err := c.LexDo(ctx, util.Procedure, "", "com.atproto.server.deleteSession", nil, nil, nil); err != nil {
 		return err
 	}
 

api/atproto/serverdescribeServer.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ServerDescribeServer_Contact is a "contact" in the com.atproto.server.describeServer schema.
···
 }
 
 // ServerDescribeServer calls the XRPC method "com.atproto.server.describeServer".
-func ServerDescribeServer(ctx context.Context, c *xrpc.Client) (*ServerDescribeServer_Output, error) {
+func ServerDescribeServer(ctx context.Context, c util.LexClient) (*ServerDescribeServer_Output, error) {
 	var out ServerDescribeServer_Output
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.server.describeServer", nil, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.server.describeServer", nil, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/servergetAccountInviteCodes.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ServerGetAccountInviteCodes_Output is the output of a com.atproto.server.getAccountInviteCodes call.
···
 // ServerGetAccountInviteCodes calls the XRPC method "com.atproto.server.getAccountInviteCodes".
 //
 // createAvailable: Controls whether any new 'earned' but not 'created' invites should be created.
-func ServerGetAccountInviteCodes(ctx context.Context, c *xrpc.Client, createAvailable bool, includeUsed bool) (*ServerGetAccountInviteCodes_Output, error) {
+func ServerGetAccountInviteCodes(ctx context.Context, c util.LexClient, createAvailable bool, includeUsed bool) (*ServerGetAccountInviteCodes_Output, error) {
 	var out ServerGetAccountInviteCodes_Output
 
 	params := map[string]interface{}{}
···
 	if includeUsed {
 		params["includeUsed"] = includeUsed
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.server.getAccountInviteCodes", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.server.getAccountInviteCodes", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/servergetServiceAuth.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ServerGetServiceAuth_Output is the output of a com.atproto.server.getServiceAuth call.
···
 // aud: The DID of the service that the token will be used to authenticate with
 // exp: The time in Unix Epoch seconds that the JWT expires. Defaults to 60 seconds in the future. The service may enforce certain time bounds on tokens depending on the requested scope.
 // lxm: Lexicon (XRPC) method to bind the requested token to
-func ServerGetServiceAuth(ctx context.Context, c *xrpc.Client, aud string, exp int64, lxm string) (*ServerGetServiceAuth_Output, error) {
+func ServerGetServiceAuth(ctx context.Context, c util.LexClient, aud string, exp int64, lxm string) (*ServerGetServiceAuth_Output, error) {
 	var out ServerGetServiceAuth_Output
 
 	params := map[string]interface{}{}
···
 	if lxm != "" {
 		params["lxm"] = lxm
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.server.getServiceAuth", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.server.getServiceAuth", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/servergetSession.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ServerGetSession_Output is the output of a com.atproto.server.getSession call.
···
 }
 
 // ServerGetSession calls the XRPC method "com.atproto.server.getSession".
-func ServerGetSession(ctx context.Context, c *xrpc.Client) (*ServerGetSession_Output, error) {
+func ServerGetSession(ctx context.Context, c util.LexClient) (*ServerGetSession_Output, error) {
 	var out ServerGetSession_Output
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.server.getSession", nil, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.server.getSession", nil, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/serverlistAppPasswords.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ServerListAppPasswords_AppPassword is a "appPassword" in the com.atproto.server.listAppPasswords schema.
···
 }
 
 // ServerListAppPasswords calls the XRPC method "com.atproto.server.listAppPasswords".
-func ServerListAppPasswords(ctx context.Context, c *xrpc.Client) (*ServerListAppPasswords_Output, error) {
+func ServerListAppPasswords(ctx context.Context, c util.LexClient) (*ServerListAppPasswords_Output, error) {
 	var out ServerListAppPasswords_Output
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.server.listAppPasswords", nil, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.server.listAppPasswords", nil, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/serverrefreshSession.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ServerRefreshSession_Output is the output of a com.atproto.server.refreshSession call.
···
 }
 
 // ServerRefreshSession calls the XRPC method "com.atproto.server.refreshSession".
-func ServerRefreshSession(ctx context.Context, c *xrpc.Client) (*ServerRefreshSession_Output, error) {
+func ServerRefreshSession(ctx context.Context, c util.LexClient) (*ServerRefreshSession_Output, error) {
 	var out ServerRefreshSession_Output
-	if err := c.Do(ctx, xrpc.Procedure, "", "com.atproto.server.refreshSession", nil, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "", "com.atproto.server.refreshSession", nil, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/serverrequestAccountDelete.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ServerRequestAccountDelete calls the XRPC method "com.atproto.server.requestAccountDelete".
-func ServerRequestAccountDelete(ctx context.Context, c *xrpc.Client) error {
-	if err := c.Do(ctx, xrpc.Procedure, "", "com.atproto.server.requestAccountDelete", nil, nil, nil); err != nil {
+func ServerRequestAccountDelete(ctx context.Context, c util.LexClient) error {
+	if err := c.LexDo(ctx, util.Procedure, "", "com.atproto.server.requestAccountDelete", nil, nil, nil); err != nil {
 		return err
 	}
 

api/atproto/serverrequestEmailConfirmation.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ServerRequestEmailConfirmation calls the XRPC method "com.atproto.server.requestEmailConfirmation".
-func ServerRequestEmailConfirmation(ctx context.Context, c *xrpc.Client) error {
-	if err := c.Do(ctx, xrpc.Procedure, "", "com.atproto.server.requestEmailConfirmation", nil, nil, nil); err != nil {
+func ServerRequestEmailConfirmation(ctx context.Context, c util.LexClient) error {
+	if err := c.LexDo(ctx, util.Procedure, "", "com.atproto.server.requestEmailConfirmation", nil, nil, nil); err != nil {
 		return err
 	}
 

api/atproto/serverrequestEmailUpdate.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ServerRequestEmailUpdate_Output is the output of a com.atproto.server.requestEmailUpdate call.
···
 }
 
 // ServerRequestEmailUpdate calls the XRPC method "com.atproto.server.requestEmailUpdate".
-func ServerRequestEmailUpdate(ctx context.Context, c *xrpc.Client) (*ServerRequestEmailUpdate_Output, error) {
+func ServerRequestEmailUpdate(ctx context.Context, c util.LexClient) (*ServerRequestEmailUpdate_Output, error) {
 	var out ServerRequestEmailUpdate_Output
-	if err := c.Do(ctx, xrpc.Procedure, "", "com.atproto.server.requestEmailUpdate", nil, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "", "com.atproto.server.requestEmailUpdate", nil, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/serverrequestPasswordReset.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ServerRequestPasswordReset_Input is the input argument to a com.atproto.server.requestPasswordReset call.
···
 }
 
 // ServerRequestPasswordReset calls the XRPC method "com.atproto.server.requestPasswordReset".
-func ServerRequestPasswordReset(ctx context.Context, c *xrpc.Client, input *ServerRequestPasswordReset_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.server.requestPasswordReset", nil, input, nil); err != nil {
+func ServerRequestPasswordReset(ctx context.Context, c util.LexClient, input *ServerRequestPasswordReset_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.server.requestPasswordReset", nil, input, nil); err != nil {
 		return err
 	}
 

api/atproto/serverreserveSigningKey.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ServerReserveSigningKey_Input is the input argument to a com.atproto.server.reserveSigningKey call.
···
 }
 
 // ServerReserveSigningKey calls the XRPC method "com.atproto.server.reserveSigningKey".
-func ServerReserveSigningKey(ctx context.Context, c *xrpc.Client, input *ServerReserveSigningKey_Input) (*ServerReserveSigningKey_Output, error) {
+func ServerReserveSigningKey(ctx context.Context, c util.LexClient, input *ServerReserveSigningKey_Input) (*ServerReserveSigningKey_Output, error) {
 	var out ServerReserveSigningKey_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.server.reserveSigningKey", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.server.reserveSigningKey", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/serverresetPassword.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ServerResetPassword_Input is the input argument to a com.atproto.server.resetPassword call.
···
 }
 
 // ServerResetPassword calls the XRPC method "com.atproto.server.resetPassword".
-func ServerResetPassword(ctx context.Context, c *xrpc.Client, input *ServerResetPassword_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.server.resetPassword", nil, input, nil); err != nil {
+func ServerResetPassword(ctx context.Context, c util.LexClient, input *ServerResetPassword_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.server.resetPassword", nil, input, nil); err != nil {
 		return err
 	}
 

api/atproto/serverrevokeAppPassword.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ServerRevokeAppPassword_Input is the input argument to a com.atproto.server.revokeAppPassword call.
···
 }
 
 // ServerRevokeAppPassword calls the XRPC method "com.atproto.server.revokeAppPassword".
-func ServerRevokeAppPassword(ctx context.Context, c *xrpc.Client, input *ServerRevokeAppPassword_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.server.revokeAppPassword", nil, input, nil); err != nil {
+func ServerRevokeAppPassword(ctx context.Context, c util.LexClient, input *ServerRevokeAppPassword_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.server.revokeAppPassword", nil, input, nil); err != nil {
 		return err
 	}
 

api/atproto/serverupdateEmail.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ServerUpdateEmail_Input is the input argument to a com.atproto.server.updateEmail call.
···
 }
 
 // ServerUpdateEmail calls the XRPC method "com.atproto.server.updateEmail".
-func ServerUpdateEmail(ctx context.Context, c *xrpc.Client, input *ServerUpdateEmail_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.server.updateEmail", nil, input, nil); err != nil {
+func ServerUpdateEmail(ctx context.Context, c util.LexClient, input *ServerUpdateEmail_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.server.updateEmail", nil, input, nil); err != nil {
 		return err
 	}
 

api/atproto/syncgetBlob.go

···
 	"bytes"
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // SyncGetBlob calls the XRPC method "com.atproto.sync.getBlob".
 //
 // cid: The CID of the blob to fetch
 // did: The DID of the account.
-func SyncGetBlob(ctx context.Context, c *xrpc.Client, cid string, did string) ([]byte, error) {
+func SyncGetBlob(ctx context.Context, c util.LexClient, cid string, did string) ([]byte, error) {
 	buf := new(bytes.Buffer)
 
 	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 {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.sync.getBlob", params, nil, buf); err != nil {
 		return nil, err
 	}
 

api/atproto/syncgetBlocks.go

···
 	"bytes"
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // SyncGetBlocks calls the XRPC method "com.atproto.sync.getBlocks".
 //
 // did: The DID of the repo.
-func SyncGetBlocks(ctx context.Context, c *xrpc.Client, cids []string, did string) ([]byte, error) {
+func SyncGetBlocks(ctx context.Context, c util.LexClient, cids []string, did string) ([]byte, error) {
 	buf := new(bytes.Buffer)
 
 	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 {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.sync.getBlocks", params, nil, buf); err != nil {
 		return nil, err
 	}
 

api/atproto/syncgetCheckout.go

···
 	"bytes"
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // SyncGetCheckout calls the XRPC method "com.atproto.sync.getCheckout".
 //
 // did: The DID of the repo.
-func SyncGetCheckout(ctx context.Context, c *xrpc.Client, did string) ([]byte, error) {
+func SyncGetCheckout(ctx context.Context, c util.LexClient, did string) ([]byte, error) {
 	buf := new(bytes.Buffer)
 
 	params := map[string]interface{}{}
 	params["did"] = did
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.sync.getCheckout", params, nil, buf); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.sync.getCheckout", params, nil, buf); err != nil {
 		return nil, err
 	}
 

api/atproto/syncgetHead.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // SyncGetHead_Output is the output of a com.atproto.sync.getHead call.
···
 // SyncGetHead calls the XRPC method "com.atproto.sync.getHead".
 //
 // did: The DID of the repo.
-func SyncGetHead(ctx context.Context, c *xrpc.Client, did string) (*SyncGetHead_Output, error) {
+func SyncGetHead(ctx context.Context, c util.LexClient, did string) (*SyncGetHead_Output, error) {
 	var out SyncGetHead_Output
 
 	params := map[string]interface{}{}
 	params["did"] = did
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.sync.getHead", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.sync.getHead", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/syncgetHostStatus.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // SyncGetHostStatus_Output is the output of a com.atproto.sync.getHostStatus call.
···
 // SyncGetHostStatus calls the XRPC method "com.atproto.sync.getHostStatus".
 //
 // hostname: Hostname of the host (eg, PDS or relay) being queried.
-func SyncGetHostStatus(ctx context.Context, c *xrpc.Client, hostname string) (*SyncGetHostStatus_Output, error) {
+func SyncGetHostStatus(ctx context.Context, c util.LexClient, hostname string) (*SyncGetHostStatus_Output, error) {
 	var out SyncGetHostStatus_Output
 
 	params := map[string]interface{}{}
 	params["hostname"] = hostname
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.sync.getHostStatus", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.sync.getHostStatus", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/syncgetLatestCommit.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // SyncGetLatestCommit_Output is the output of a com.atproto.sync.getLatestCommit call.
···
 // SyncGetLatestCommit calls the XRPC method "com.atproto.sync.getLatestCommit".
 //
 // did: The DID of the repo.
-func SyncGetLatestCommit(ctx context.Context, c *xrpc.Client, did string) (*SyncGetLatestCommit_Output, error) {
+func SyncGetLatestCommit(ctx context.Context, c util.LexClient, did string) (*SyncGetLatestCommit_Output, error) {
 	var out SyncGetLatestCommit_Output
 
 	params := map[string]interface{}{}
 	params["did"] = did
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.sync.getLatestCommit", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.sync.getLatestCommit", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/syncgetRecord.go

···
 	"bytes"
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // SyncGetRecord calls the XRPC method "com.atproto.sync.getRecord".
 //
 // did: The DID of the repo.
 // rkey: Record Key
-func SyncGetRecord(ctx context.Context, c *xrpc.Client, collection string, did string, rkey string) ([]byte, error) {
+func SyncGetRecord(ctx context.Context, c util.LexClient, collection string, did string, rkey string) ([]byte, error) {
 	buf := new(bytes.Buffer)
 
 	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 {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.sync.getRecord", params, nil, buf); err != nil {
 		return nil, err
 	}
 

api/atproto/syncgetRepo.go

···
 	"bytes"
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // SyncGetRepo calls the XRPC method "com.atproto.sync.getRepo".
 //
 // did: The DID of the repo.
 // since: The revision ('rev') of the repo to create a diff from.
-func SyncGetRepo(ctx context.Context, c *xrpc.Client, did string, since string) ([]byte, error) {
+func SyncGetRepo(ctx context.Context, c util.LexClient, did string, since string) ([]byte, error) {
 	buf := new(bytes.Buffer)
 
 	params := map[string]interface{}{}
···
 	if since != "" {
 		params["since"] = since
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.sync.getRepo", params, nil, buf); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.sync.getRepo", params, nil, buf); err != nil {
 		return nil, err
 	}
 

api/atproto/syncgetRepoStatus.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // SyncGetRepoStatus_Output is the output of a com.atproto.sync.getRepoStatus call.
···
 // SyncGetRepoStatus calls the XRPC method "com.atproto.sync.getRepoStatus".
 //
 // did: The DID of the repo.
-func SyncGetRepoStatus(ctx context.Context, c *xrpc.Client, did string) (*SyncGetRepoStatus_Output, error) {
+func SyncGetRepoStatus(ctx context.Context, c util.LexClient, did string) (*SyncGetRepoStatus_Output, error) {
 	var out SyncGetRepoStatus_Output
 
 	params := map[string]interface{}{}
 	params["did"] = did
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.sync.getRepoStatus", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.sync.getRepoStatus", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/synclistBlobs.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // SyncListBlobs_Output is the output of a com.atproto.sync.listBlobs call.
···
 //
 // did: The DID of the repo.
 // since: Optional revision of the repo to list blobs since.
-func SyncListBlobs(ctx context.Context, c *xrpc.Client, cursor string, did string, limit int64, since string) (*SyncListBlobs_Output, error) {
+func SyncListBlobs(ctx context.Context, c util.LexClient, cursor string, did string, limit int64, since string) (*SyncListBlobs_Output, error) {
 	var out SyncListBlobs_Output
 
 	params := map[string]interface{}{}
···
 	if since != "" {
 		params["since"] = since
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.sync.listBlobs", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.sync.listBlobs", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/synclistHosts.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // SyncListHosts_Host is a "host" in the com.atproto.sync.listHosts schema.
···
 }
 
 // SyncListHosts calls the XRPC method "com.atproto.sync.listHosts".
-func SyncListHosts(ctx context.Context, c *xrpc.Client, cursor string, limit int64) (*SyncListHosts_Output, error) {
+func SyncListHosts(ctx context.Context, c util.LexClient, cursor string, limit int64) (*SyncListHosts_Output, error) {
 	var out SyncListHosts_Output
 
 	params := map[string]interface{}{}
···
 	if limit != 0 {
 		params["limit"] = limit
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.sync.listHosts", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.sync.listHosts", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/synclistRepos.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // SyncListRepos_Output is the output of a com.atproto.sync.listRepos call.
···
 }
 
 // SyncListRepos calls the XRPC method "com.atproto.sync.listRepos".
-func SyncListRepos(ctx context.Context, c *xrpc.Client, cursor string, limit int64) (*SyncListRepos_Output, error) {
+func SyncListRepos(ctx context.Context, c util.LexClient, cursor string, limit int64) (*SyncListRepos_Output, error) {
 	var out SyncListRepos_Output
 
 	params := map[string]interface{}{}
···
 	if limit != 0 {
 		params["limit"] = limit
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.sync.listRepos", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.sync.listRepos", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/synclistReposByCollection.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // SyncListReposByCollection_Output is the output of a com.atproto.sync.listReposByCollection call.
···
 // SyncListReposByCollection calls the XRPC method "com.atproto.sync.listReposByCollection".
 //
 // limit: Maximum size of response set. Recommend setting a large maximum (1000+) when enumerating large DID lists.
-func SyncListReposByCollection(ctx context.Context, c *xrpc.Client, collection string, cursor string, limit int64) (*SyncListReposByCollection_Output, error) {
+func SyncListReposByCollection(ctx context.Context, c util.LexClient, collection string, cursor string, limit int64) (*SyncListReposByCollection_Output, error) {
 	var out SyncListReposByCollection_Output
 
 	params := map[string]interface{}{}
···
 	if limit != 0 {
 		params["limit"] = limit
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.sync.listReposByCollection", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.sync.listReposByCollection", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/syncnotifyOfUpdate.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // SyncNotifyOfUpdate_Input is the input argument to a com.atproto.sync.notifyOfUpdate call.
···
 }
 
 // SyncNotifyOfUpdate calls the XRPC method "com.atproto.sync.notifyOfUpdate".
-func SyncNotifyOfUpdate(ctx context.Context, c *xrpc.Client, input *SyncNotifyOfUpdate_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.sync.notifyOfUpdate", nil, input, nil); err != nil {
+func SyncNotifyOfUpdate(ctx context.Context, c util.LexClient, input *SyncNotifyOfUpdate_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.sync.notifyOfUpdate", nil, input, nil); err != nil {
 		return err
 	}
 

api/atproto/syncrequestCrawl.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // SyncRequestCrawl_Input is the input argument to a com.atproto.sync.requestCrawl call.
···
 }
 
 // SyncRequestCrawl calls the XRPC method "com.atproto.sync.requestCrawl".
-func SyncRequestCrawl(ctx context.Context, c *xrpc.Client, input *SyncRequestCrawl_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.sync.requestCrawl", nil, input, nil); err != nil {
+func SyncRequestCrawl(ctx context.Context, c util.LexClient, input *SyncRequestCrawl_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.sync.requestCrawl", nil, input, nil); err != nil {
 		return err
 	}
 

api/atproto/tempaddReservedHandle.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // TempAddReservedHandle_Input is the input argument to a com.atproto.temp.addReservedHandle call.
···
 }
 
 // TempAddReservedHandle calls the XRPC method "com.atproto.temp.addReservedHandle".
-func TempAddReservedHandle(ctx context.Context, c *xrpc.Client, input *TempAddReservedHandle_Input) (*TempAddReservedHandle_Output, error) {
+func TempAddReservedHandle(ctx context.Context, c util.LexClient, input *TempAddReservedHandle_Input) (*TempAddReservedHandle_Output, error) {
 	var out TempAddReservedHandle_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.temp.addReservedHandle", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.temp.addReservedHandle", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/tempcheckSignupQueue.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // TempCheckSignupQueue_Output is the output of a com.atproto.temp.checkSignupQueue call.
···
 }
 
 // TempCheckSignupQueue calls the XRPC method "com.atproto.temp.checkSignupQueue".
-func TempCheckSignupQueue(ctx context.Context, c *xrpc.Client) (*TempCheckSignupQueue_Output, error) {
+func TempCheckSignupQueue(ctx context.Context, c util.LexClient) (*TempCheckSignupQueue_Output, error) {
 	var out TempCheckSignupQueue_Output
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.temp.checkSignupQueue", nil, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.temp.checkSignupQueue", nil, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/tempfetchLabels.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // TempFetchLabels_Output is the output of a com.atproto.temp.fetchLabels call.
···
 }
 
 // TempFetchLabels calls the XRPC method "com.atproto.temp.fetchLabels".
-func TempFetchLabels(ctx context.Context, c *xrpc.Client, limit int64, since int64) (*TempFetchLabels_Output, error) {
+func TempFetchLabels(ctx context.Context, c util.LexClient, limit int64, since int64) (*TempFetchLabels_Output, error) {
 	var out TempFetchLabels_Output
 
 	params := map[string]interface{}{}
···
 	if since != 0 {
 		params["since"] = since
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.temp.fetchLabels", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.temp.fetchLabels", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/temprequestPhoneVerification.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // TempRequestPhoneVerification_Input is the input argument to a com.atproto.temp.requestPhoneVerification call.
···
 }
 
 // TempRequestPhoneVerification calls the XRPC method "com.atproto.temp.requestPhoneVerification".
-func TempRequestPhoneVerification(ctx context.Context, c *xrpc.Client, input *TempRequestPhoneVerification_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.temp.requestPhoneVerification", nil, input, nil); err != nil {
+func TempRequestPhoneVerification(ctx context.Context, c util.LexClient, input *TempRequestPhoneVerification_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.temp.requestPhoneVerification", nil, input, nil); err != nil {
 		return err
 	}
 

api/bsky/actorgetPreferences.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ActorGetPreferences_Output is the output of a app.bsky.actor.getPreferences call.
···
 }
 
 // ActorGetPreferences calls the XRPC method "app.bsky.actor.getPreferences".
-func ActorGetPreferences(ctx context.Context, c *xrpc.Client) (*ActorGetPreferences_Output, error) {
+func ActorGetPreferences(ctx context.Context, c util.LexClient) (*ActorGetPreferences_Output, error) {
 	var out ActorGetPreferences_Output
 
 	params := map[string]interface{}{}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.actor.getPreferences", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.actor.getPreferences", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/actorgetProfile.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ActorGetProfile calls the XRPC method "app.bsky.actor.getProfile".
 //
 // actor: Handle or DID of account to fetch profile of.
-func ActorGetProfile(ctx context.Context, c *xrpc.Client, actor string) (*ActorDefs_ProfileViewDetailed, error) {
+func ActorGetProfile(ctx context.Context, c util.LexClient, actor string) (*ActorDefs_ProfileViewDetailed, error) {
 	var out ActorDefs_ProfileViewDetailed
 
 	params := map[string]interface{}{}
 	params["actor"] = actor
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.actor.getProfile", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.actor.getProfile", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/actorgetProfiles.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ActorGetProfiles_Output is the output of a app.bsky.actor.getProfiles call.
···
 }
 
 // ActorGetProfiles calls the XRPC method "app.bsky.actor.getProfiles".
-func ActorGetProfiles(ctx context.Context, c *xrpc.Client, actors []string) (*ActorGetProfiles_Output, error) {
+func ActorGetProfiles(ctx context.Context, c util.LexClient, actors []string) (*ActorGetProfiles_Output, error) {
 	var out ActorGetProfiles_Output
 
 	params := map[string]interface{}{}
 	params["actors"] = actors
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.actor.getProfiles", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.actor.getProfiles", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/actorgetSuggestions.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ActorGetSuggestions_Output is the output of a app.bsky.actor.getSuggestions call.
···
 }
 
 // ActorGetSuggestions calls the XRPC method "app.bsky.actor.getSuggestions".
-func ActorGetSuggestions(ctx context.Context, c *xrpc.Client, cursor string, limit int64) (*ActorGetSuggestions_Output, error) {
+func ActorGetSuggestions(ctx context.Context, c util.LexClient, cursor string, limit int64) (*ActorGetSuggestions_Output, error) {
 	var out ActorGetSuggestions_Output
 
 	params := map[string]interface{}{}
···
 	if limit != 0 {
 		params["limit"] = limit
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.actor.getSuggestions", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.actor.getSuggestions", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/actorputPreferences.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ActorPutPreferences_Input is the input argument to a app.bsky.actor.putPreferences call.
···
 }
 
 // ActorPutPreferences calls the XRPC method "app.bsky.actor.putPreferences".
-func ActorPutPreferences(ctx context.Context, c *xrpc.Client, input *ActorPutPreferences_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "app.bsky.actor.putPreferences", nil, input, nil); err != nil {
+func ActorPutPreferences(ctx context.Context, c util.LexClient, input *ActorPutPreferences_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "app.bsky.actor.putPreferences", nil, input, nil); err != nil {
 		return err
 	}
 

api/bsky/actorsearchActors.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ActorSearchActors_Output is the output of a app.bsky.actor.searchActors call.
···
 //
 // q: Search query string. Syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended.
 // term: DEPRECATED: use 'q' instead.
-func ActorSearchActors(ctx context.Context, c *xrpc.Client, cursor string, limit int64, q string, term string) (*ActorSearchActors_Output, error) {
+func ActorSearchActors(ctx context.Context, c util.LexClient, cursor string, limit int64, q string, term string) (*ActorSearchActors_Output, error) {
 	var out ActorSearchActors_Output
 
 	params := map[string]interface{}{}
···
 	if term != "" {
 		params["term"] = term
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.actor.searchActors", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.actor.searchActors", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/actorsearchActorsTypeahead.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ActorSearchActorsTypeahead_Output is the output of a app.bsky.actor.searchActorsTypeahead call.
···
 //
 // q: Search query prefix; not a full query string.
 // term: DEPRECATED: use 'q' instead.
-func ActorSearchActorsTypeahead(ctx context.Context, c *xrpc.Client, limit int64, q string, term string) (*ActorSearchActorsTypeahead_Output, error) {
+func ActorSearchActorsTypeahead(ctx context.Context, c util.LexClient, limit int64, q string, term string) (*ActorSearchActorsTypeahead_Output, error) {
 	var out ActorSearchActorsTypeahead_Output
 
 	params := map[string]interface{}{}
···
 	if term != "" {
 		params["term"] = term
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.actor.searchActorsTypeahead", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.actor.searchActorsTypeahead", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/feeddescribeFeedGenerator.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // FeedDescribeFeedGenerator_Feed is a "feed" in the app.bsky.feed.describeFeedGenerator schema.
···
 }
 
 // FeedDescribeFeedGenerator calls the XRPC method "app.bsky.feed.describeFeedGenerator".
-func FeedDescribeFeedGenerator(ctx context.Context, c *xrpc.Client) (*FeedDescribeFeedGenerator_Output, error) {
+func FeedDescribeFeedGenerator(ctx context.Context, c util.LexClient) (*FeedDescribeFeedGenerator_Output, error) {
 	var out FeedDescribeFeedGenerator_Output
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.describeFeedGenerator", nil, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.feed.describeFeedGenerator", nil, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/feedgetActorFeeds.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // FeedGetActorFeeds_Output is the output of a app.bsky.feed.getActorFeeds call.
···
 }
 
 // FeedGetActorFeeds calls the XRPC method "app.bsky.feed.getActorFeeds".
-func FeedGetActorFeeds(ctx context.Context, c *xrpc.Client, actor string, cursor string, limit int64) (*FeedGetActorFeeds_Output, error) {
+func FeedGetActorFeeds(ctx context.Context, c util.LexClient, actor string, cursor string, limit int64) (*FeedGetActorFeeds_Output, error) {
 	var out FeedGetActorFeeds_Output
 
 	params := map[string]interface{}{}
···
 	if limit != 0 {
 		params["limit"] = limit
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getActorFeeds", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.feed.getActorFeeds", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/feedgetActorLikes.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // FeedGetActorLikes_Output is the output of a app.bsky.feed.getActorLikes call.
···
 }
 
 // FeedGetActorLikes calls the XRPC method "app.bsky.feed.getActorLikes".
-func FeedGetActorLikes(ctx context.Context, c *xrpc.Client, actor string, cursor string, limit int64) (*FeedGetActorLikes_Output, error) {
+func FeedGetActorLikes(ctx context.Context, c util.LexClient, actor string, cursor string, limit int64) (*FeedGetActorLikes_Output, error) {
 	var out FeedGetActorLikes_Output
 
 	params := map[string]interface{}{}
···
 	if limit != 0 {
 		params["limit"] = limit
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getActorLikes", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.feed.getActorLikes", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/feedgetAuthorFeed.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // FeedGetAuthorFeed_Output is the output of a app.bsky.feed.getAuthorFeed call.
···
 // FeedGetAuthorFeed calls the XRPC method "app.bsky.feed.getAuthorFeed".
 //
 // filter: Combinations of post/repost types to include in response.
-func FeedGetAuthorFeed(ctx context.Context, c *xrpc.Client, actor string, cursor string, filter string, includePins bool, limit int64) (*FeedGetAuthorFeed_Output, error) {
+func FeedGetAuthorFeed(ctx context.Context, c util.LexClient, actor string, cursor string, filter string, includePins bool, limit int64) (*FeedGetAuthorFeed_Output, error) {
 	var out FeedGetAuthorFeed_Output
 
 	params := map[string]interface{}{}
···
 	if limit != 0 {
 		params["limit"] = limit
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getAuthorFeed", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.feed.getAuthorFeed", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/feedgetFeed.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // FeedGetFeed_Output is the output of a app.bsky.feed.getFeed call.
···
 }
 
 // FeedGetFeed calls the XRPC method "app.bsky.feed.getFeed".
-func FeedGetFeed(ctx context.Context, c *xrpc.Client, cursor string, feed string, limit int64) (*FeedGetFeed_Output, error) {
+func FeedGetFeed(ctx context.Context, c util.LexClient, cursor string, feed string, limit int64) (*FeedGetFeed_Output, error) {
 	var out FeedGetFeed_Output
 
 	params := map[string]interface{}{}
···
 	if limit != 0 {
 		params["limit"] = limit
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getFeed", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.feed.getFeed", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/feedgetFeedGenerator.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // FeedGetFeedGenerator_Output is the output of a app.bsky.feed.getFeedGenerator call.
···
 // FeedGetFeedGenerator calls the XRPC method "app.bsky.feed.getFeedGenerator".
 //
 // feed: AT-URI of the feed generator record.
-func FeedGetFeedGenerator(ctx context.Context, c *xrpc.Client, feed string) (*FeedGetFeedGenerator_Output, error) {
+func FeedGetFeedGenerator(ctx context.Context, c util.LexClient, feed string) (*FeedGetFeedGenerator_Output, error) {
 	var out FeedGetFeedGenerator_Output
 
 	params := map[string]interface{}{}
 	params["feed"] = feed
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getFeedGenerator", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.feed.getFeedGenerator", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/feedgetFeedGenerators.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // FeedGetFeedGenerators_Output is the output of a app.bsky.feed.getFeedGenerators call.
···
 }
 
 // FeedGetFeedGenerators calls the XRPC method "app.bsky.feed.getFeedGenerators".
-func FeedGetFeedGenerators(ctx context.Context, c *xrpc.Client, feeds []string) (*FeedGetFeedGenerators_Output, error) {
+func FeedGetFeedGenerators(ctx context.Context, c util.LexClient, feeds []string) (*FeedGetFeedGenerators_Output, error) {
 	var out FeedGetFeedGenerators_Output
 
 	params := map[string]interface{}{}
 	params["feeds"] = feeds
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getFeedGenerators", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.feed.getFeedGenerators", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/feedgetFeedSkeleton.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // FeedGetFeedSkeleton_Output is the output of a app.bsky.feed.getFeedSkeleton call.
···
 // FeedGetFeedSkeleton calls the XRPC method "app.bsky.feed.getFeedSkeleton".
 //
 // feed: Reference to feed generator record describing the specific feed being requested.
-func FeedGetFeedSkeleton(ctx context.Context, c *xrpc.Client, cursor string, feed string, limit int64) (*FeedGetFeedSkeleton_Output, error) {
+func FeedGetFeedSkeleton(ctx context.Context, c util.LexClient, cursor string, feed string, limit int64) (*FeedGetFeedSkeleton_Output, error) {
 	var out FeedGetFeedSkeleton_Output
 
 	params := map[string]interface{}{}
···
 	if limit != 0 {
 		params["limit"] = limit
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getFeedSkeleton", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.feed.getFeedSkeleton", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/feedgetLikes.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // FeedGetLikes_Like is a "like" in the app.bsky.feed.getLikes schema.
···
 //
 // cid: CID of the subject record (aka, specific version of record), to filter likes.
 // uri: AT-URI of the subject (eg, a post record).
-func FeedGetLikes(ctx context.Context, c *xrpc.Client, cid string, cursor string, limit int64, uri string) (*FeedGetLikes_Output, error) {
+func FeedGetLikes(ctx context.Context, c util.LexClient, cid string, cursor string, limit int64, uri string) (*FeedGetLikes_Output, error) {
 	var out FeedGetLikes_Output
 
 	params := map[string]interface{}{}
···
 		params["limit"] = limit
 	}
 	params["uri"] = uri
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getLikes", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.feed.getLikes", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/feedgetListFeed.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // FeedGetListFeed_Output is the output of a app.bsky.feed.getListFeed call.
···
 // FeedGetListFeed calls the XRPC method "app.bsky.feed.getListFeed".
 //
 // list: Reference (AT-URI) to the list record.
-func FeedGetListFeed(ctx context.Context, c *xrpc.Client, cursor string, limit int64, list string) (*FeedGetListFeed_Output, error) {
+func FeedGetListFeed(ctx context.Context, c util.LexClient, cursor string, limit int64, list string) (*FeedGetListFeed_Output, error) {
 	var out FeedGetListFeed_Output
 
 	params := map[string]interface{}{}
···
 		params["limit"] = limit
 	}
 	params["list"] = list
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getListFeed", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.feed.getListFeed", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/feedgetPostThread.go

···
 	"fmt"
 
 	"github.com/bluesky-social/indigo/lex/util"
-	"github.com/bluesky-social/indigo/xrpc"
 )
 
 // FeedGetPostThread_Output is the output of a app.bsky.feed.getPostThread call.
···
 // depth: How many levels of reply depth should be included in response.
 // parentHeight: How many levels of parent (and grandparent, etc) post to include.
 // uri: Reference (AT-URI) to post record.
-func FeedGetPostThread(ctx context.Context, c *xrpc.Client, depth int64, parentHeight int64, uri string) (*FeedGetPostThread_Output, error) {
+func FeedGetPostThread(ctx context.Context, c util.LexClient, depth int64, parentHeight int64, uri string) (*FeedGetPostThread_Output, error) {
 	var out FeedGetPostThread_Output
 
 	params := map[string]interface{}{}
···
 		params["parentHeight"] = parentHeight
 	}
 	params["uri"] = uri
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getPostThread", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.feed.getPostThread", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/feedgetPosts.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // FeedGetPosts_Output is the output of a app.bsky.feed.getPosts call.
···
 // FeedGetPosts calls the XRPC method "app.bsky.feed.getPosts".
 //
 // uris: List of post AT-URIs to return hydrated views for.
-func FeedGetPosts(ctx context.Context, c *xrpc.Client, uris []string) (*FeedGetPosts_Output, error) {
+func FeedGetPosts(ctx context.Context, c util.LexClient, uris []string) (*FeedGetPosts_Output, error) {
 	var out FeedGetPosts_Output
 
 	params := map[string]interface{}{}
 	params["uris"] = uris
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getPosts", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.feed.getPosts", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/feedgetQuotes.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // FeedGetQuotes_Output is the output of a app.bsky.feed.getQuotes call.
···
 //
 // cid: If supplied, filters to quotes of specific version (by CID) of the post record.
 // uri: Reference (AT-URI) of post record
-func FeedGetQuotes(ctx context.Context, c *xrpc.Client, cid string, cursor string, limit int64, uri string) (*FeedGetQuotes_Output, error) {
+func FeedGetQuotes(ctx context.Context, c util.LexClient, cid string, cursor string, limit int64, uri string) (*FeedGetQuotes_Output, error) {
 	var out FeedGetQuotes_Output
 
 	params := map[string]interface{}{}
···
 		params["limit"] = limit
 	}
 	params["uri"] = uri
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getQuotes", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.feed.getQuotes", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/feedgetRepostedBy.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // FeedGetRepostedBy_Output is the output of a app.bsky.feed.getRepostedBy call.
···
 //
 // cid: If supplied, filters to reposts of specific version (by CID) of the post record.
 // uri: Reference (AT-URI) of post record
-func FeedGetRepostedBy(ctx context.Context, c *xrpc.Client, cid string, cursor string, limit int64, uri string) (*FeedGetRepostedBy_Output, error) {
+func FeedGetRepostedBy(ctx context.Context, c util.LexClient, cid string, cursor string, limit int64, uri string) (*FeedGetRepostedBy_Output, error) {
 	var out FeedGetRepostedBy_Output
 
 	params := map[string]interface{}{}
···
 		params["limit"] = limit
 	}
 	params["uri"] = uri
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getRepostedBy", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.feed.getRepostedBy", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/feedgetSuggestedFeeds.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // FeedGetSuggestedFeeds_Output is the output of a app.bsky.feed.getSuggestedFeeds call.
···
 }
 
 // FeedGetSuggestedFeeds calls the XRPC method "app.bsky.feed.getSuggestedFeeds".
-func FeedGetSuggestedFeeds(ctx context.Context, c *xrpc.Client, cursor string, limit int64) (*FeedGetSuggestedFeeds_Output, error) {
+func FeedGetSuggestedFeeds(ctx context.Context, c util.LexClient, cursor string, limit int64) (*FeedGetSuggestedFeeds_Output, error) {
 	var out FeedGetSuggestedFeeds_Output
 
 	params := map[string]interface{}{}
···
 	if limit != 0 {
 		params["limit"] = limit
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getSuggestedFeeds", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.feed.getSuggestedFeeds", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/feedgetTimeline.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // FeedGetTimeline_Output is the output of a app.bsky.feed.getTimeline call.
···
 // FeedGetTimeline calls the XRPC method "app.bsky.feed.getTimeline".
 //
 // algorithm: Variant 'algorithm' for timeline. Implementation-specific. NOTE: most feed flexibility has been moved to feed generator mechanism.
-func FeedGetTimeline(ctx context.Context, c *xrpc.Client, algorithm string, cursor string, limit int64) (*FeedGetTimeline_Output, error) {
+func FeedGetTimeline(ctx context.Context, c util.LexClient, algorithm string, cursor string, limit int64) (*FeedGetTimeline_Output, error) {
 	var out FeedGetTimeline_Output
 
 	params := map[string]interface{}{}
···
 	if limit != 0 {
 		params["limit"] = limit
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.getTimeline", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.feed.getTimeline", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/feedsearchPosts.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // FeedSearchPosts_Output is the output of a app.bsky.feed.searchPosts call.
···
 // tag: Filter to posts with the given tag (hashtag), based on rich-text facet or tag field. Do not include the hash (#) prefix. Multiple tags can be specified, with 'AND' matching.
 // until: Filter results for posts before the indicated datetime (not inclusive). Expected to use 'sortAt' timestamp, which may not match 'createdAt'. Can be a datetime, or just an ISO date (YYY-MM-DD).
 // url: Filter to posts with links (facet links or embeds) pointing to this URL. Server may apply URL normalization or fuzzy matching.
-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) {
+func FeedSearchPosts(ctx context.Context, c util.LexClient, 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{}{}
···
 	if url != "" {
 		params["url"] = url
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.feed.searchPosts", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.feed.searchPosts", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/feedsendInteractions.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // FeedSendInteractions_Input is the input argument to a app.bsky.feed.sendInteractions call.
···
 }
 
 // FeedSendInteractions calls the XRPC method "app.bsky.feed.sendInteractions".
-func FeedSendInteractions(ctx context.Context, c *xrpc.Client, input *FeedSendInteractions_Input) (*FeedSendInteractions_Output, error) {
+func FeedSendInteractions(ctx context.Context, c util.LexClient, input *FeedSendInteractions_Input) (*FeedSendInteractions_Output, error) {
 	var out FeedSendInteractions_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "app.bsky.feed.sendInteractions", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "app.bsky.feed.sendInteractions", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/graphgetActorStarterPacks.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // GraphGetActorStarterPacks_Output is the output of a app.bsky.graph.getActorStarterPacks call.
···
 }
 
 // GraphGetActorStarterPacks calls the XRPC method "app.bsky.graph.getActorStarterPacks".
-func GraphGetActorStarterPacks(ctx context.Context, c *xrpc.Client, actor string, cursor string, limit int64) (*GraphGetActorStarterPacks_Output, error) {
+func GraphGetActorStarterPacks(ctx context.Context, c util.LexClient, actor string, cursor string, limit int64) (*GraphGetActorStarterPacks_Output, error) {
 	var out GraphGetActorStarterPacks_Output
 
 	params := map[string]interface{}{}
···
 	if limit != 0 {
 		params["limit"] = limit
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getActorStarterPacks", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.graph.getActorStarterPacks", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/graphgetBlocks.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // GraphGetBlocks_Output is the output of a app.bsky.graph.getBlocks call.
···
 }
 
 // GraphGetBlocks calls the XRPC method "app.bsky.graph.getBlocks".
-func GraphGetBlocks(ctx context.Context, c *xrpc.Client, cursor string, limit int64) (*GraphGetBlocks_Output, error) {
+func GraphGetBlocks(ctx context.Context, c util.LexClient, cursor string, limit int64) (*GraphGetBlocks_Output, error) {
 	var out GraphGetBlocks_Output
 
 	params := map[string]interface{}{}
···
 	if limit != 0 {
 		params["limit"] = limit
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getBlocks", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.graph.getBlocks", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/graphgetFollowers.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // GraphGetFollowers_Output is the output of a app.bsky.graph.getFollowers call.
···
 }
 
 // GraphGetFollowers calls the XRPC method "app.bsky.graph.getFollowers".
-func GraphGetFollowers(ctx context.Context, c *xrpc.Client, actor string, cursor string, limit int64) (*GraphGetFollowers_Output, error) {
+func GraphGetFollowers(ctx context.Context, c util.LexClient, actor string, cursor string, limit int64) (*GraphGetFollowers_Output, error) {
 	var out GraphGetFollowers_Output
 
 	params := map[string]interface{}{}
···
 	if limit != 0 {
 		params["limit"] = limit
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getFollowers", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.graph.getFollowers", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/graphgetFollows.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // GraphGetFollows_Output is the output of a app.bsky.graph.getFollows call.
···
 }
 
 // GraphGetFollows calls the XRPC method "app.bsky.graph.getFollows".
-func GraphGetFollows(ctx context.Context, c *xrpc.Client, actor string, cursor string, limit int64) (*GraphGetFollows_Output, error) {
+func GraphGetFollows(ctx context.Context, c util.LexClient, actor string, cursor string, limit int64) (*GraphGetFollows_Output, error) {
 	var out GraphGetFollows_Output
 
 	params := map[string]interface{}{}
···
 	if limit != 0 {
 		params["limit"] = limit
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getFollows", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.graph.getFollows", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/graphgetKnownFollowers.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // GraphGetKnownFollowers_Output is the output of a app.bsky.graph.getKnownFollowers call.
···
 }
 
 // GraphGetKnownFollowers calls the XRPC method "app.bsky.graph.getKnownFollowers".
-func GraphGetKnownFollowers(ctx context.Context, c *xrpc.Client, actor string, cursor string, limit int64) (*GraphGetKnownFollowers_Output, error) {
+func GraphGetKnownFollowers(ctx context.Context, c util.LexClient, actor string, cursor string, limit int64) (*GraphGetKnownFollowers_Output, error) {
 	var out GraphGetKnownFollowers_Output
 
 	params := map[string]interface{}{}
···
 	if limit != 0 {
 		params["limit"] = limit
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getKnownFollowers", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.graph.getKnownFollowers", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/graphgetList.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // GraphGetList_Output is the output of a app.bsky.graph.getList call.
···
 // GraphGetList calls the XRPC method "app.bsky.graph.getList".
 //
 // list: Reference (AT-URI) of the list record to hydrate.
-func GraphGetList(ctx context.Context, c *xrpc.Client, cursor string, limit int64, list string) (*GraphGetList_Output, error) {
+func GraphGetList(ctx context.Context, c util.LexClient, cursor string, limit int64, list string) (*GraphGetList_Output, error) {
 	var out GraphGetList_Output
 
 	params := map[string]interface{}{}
···
 		params["limit"] = limit
 	}
 	params["list"] = list
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getList", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.graph.getList", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/graphgetListBlocks.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // GraphGetListBlocks_Output is the output of a app.bsky.graph.getListBlocks call.
···
 }
 
 // GraphGetListBlocks calls the XRPC method "app.bsky.graph.getListBlocks".
-func GraphGetListBlocks(ctx context.Context, c *xrpc.Client, cursor string, limit int64) (*GraphGetListBlocks_Output, error) {
+func GraphGetListBlocks(ctx context.Context, c util.LexClient, cursor string, limit int64) (*GraphGetListBlocks_Output, error) {
 	var out GraphGetListBlocks_Output
 
 	params := map[string]interface{}{}
···
 	if limit != 0 {
 		params["limit"] = limit
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getListBlocks", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.graph.getListBlocks", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/graphgetListMutes.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // GraphGetListMutes_Output is the output of a app.bsky.graph.getListMutes call.
···
 }
 
 // GraphGetListMutes calls the XRPC method "app.bsky.graph.getListMutes".
-func GraphGetListMutes(ctx context.Context, c *xrpc.Client, cursor string, limit int64) (*GraphGetListMutes_Output, error) {
+func GraphGetListMutes(ctx context.Context, c util.LexClient, cursor string, limit int64) (*GraphGetListMutes_Output, error) {
 	var out GraphGetListMutes_Output
 
 	params := map[string]interface{}{}
···
 	if limit != 0 {
 		params["limit"] = limit
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getListMutes", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.graph.getListMutes", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/graphgetLists.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // GraphGetLists_Output is the output of a app.bsky.graph.getLists call.
···
 // GraphGetLists calls the XRPC method "app.bsky.graph.getLists".
 //
 // actor: The account (actor) to enumerate lists from.
-func GraphGetLists(ctx context.Context, c *xrpc.Client, actor string, cursor string, limit int64) (*GraphGetLists_Output, error) {
+func GraphGetLists(ctx context.Context, c util.LexClient, actor string, cursor string, limit int64) (*GraphGetLists_Output, error) {
 	var out GraphGetLists_Output
 
 	params := map[string]interface{}{}
···
 	if limit != 0 {
 		params["limit"] = limit
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getLists", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.graph.getLists", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/graphgetMutes.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // GraphGetMutes_Output is the output of a app.bsky.graph.getMutes call.
···
 }
 
 // GraphGetMutes calls the XRPC method "app.bsky.graph.getMutes".
-func GraphGetMutes(ctx context.Context, c *xrpc.Client, cursor string, limit int64) (*GraphGetMutes_Output, error) {
+func GraphGetMutes(ctx context.Context, c util.LexClient, cursor string, limit int64) (*GraphGetMutes_Output, error) {
 	var out GraphGetMutes_Output
 
 	params := map[string]interface{}{}
···
 	if limit != 0 {
 		params["limit"] = limit
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getMutes", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.graph.getMutes", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/graphgetRelationships.go

···
 	"fmt"
 
 	"github.com/bluesky-social/indigo/lex/util"
-	"github.com/bluesky-social/indigo/xrpc"
 )
 
 // GraphGetRelationships_Output is the output of a app.bsky.graph.getRelationships call.
···
 //
 // actor: Primary account requesting relationships for.
 // others: List of 'other' accounts to be related back to the primary.
-func GraphGetRelationships(ctx context.Context, c *xrpc.Client, actor string, others []string) (*GraphGetRelationships_Output, error) {
+func GraphGetRelationships(ctx context.Context, c util.LexClient, actor string, others []string) (*GraphGetRelationships_Output, error) {
 	var out GraphGetRelationships_Output
 
 	params := map[string]interface{}{}
···
 	if len(others) != 0 {
 		params["others"] = others
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getRelationships", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.graph.getRelationships", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/graphgetStarterPack.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // GraphGetStarterPack_Output is the output of a app.bsky.graph.getStarterPack call.
···
 // GraphGetStarterPack calls the XRPC method "app.bsky.graph.getStarterPack".
 //
 // starterPack: Reference (AT-URI) of the starter pack record.
-func GraphGetStarterPack(ctx context.Context, c *xrpc.Client, starterPack string) (*GraphGetStarterPack_Output, error) {
+func GraphGetStarterPack(ctx context.Context, c util.LexClient, starterPack string) (*GraphGetStarterPack_Output, error) {
 	var out GraphGetStarterPack_Output
 
 	params := map[string]interface{}{}
 	params["starterPack"] = starterPack
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getStarterPack", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.graph.getStarterPack", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/graphgetStarterPacks.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // GraphGetStarterPacks_Output is the output of a app.bsky.graph.getStarterPacks call.
···
 }
 
 // GraphGetStarterPacks calls the XRPC method "app.bsky.graph.getStarterPacks".
-func GraphGetStarterPacks(ctx context.Context, c *xrpc.Client, uris []string) (*GraphGetStarterPacks_Output, error) {
+func GraphGetStarterPacks(ctx context.Context, c util.LexClient, uris []string) (*GraphGetStarterPacks_Output, error) {
 	var out GraphGetStarterPacks_Output
 
 	params := map[string]interface{}{}
 	params["uris"] = uris
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getStarterPacks", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.graph.getStarterPacks", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/graphgetSuggestedFollowsByActor.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // GraphGetSuggestedFollowsByActor_Output is the output of a app.bsky.graph.getSuggestedFollowsByActor call.
···
 }
 
 // GraphGetSuggestedFollowsByActor calls the XRPC method "app.bsky.graph.getSuggestedFollowsByActor".
-func GraphGetSuggestedFollowsByActor(ctx context.Context, c *xrpc.Client, actor string) (*GraphGetSuggestedFollowsByActor_Output, error) {
+func GraphGetSuggestedFollowsByActor(ctx context.Context, c util.LexClient, actor string) (*GraphGetSuggestedFollowsByActor_Output, error) {
 	var out GraphGetSuggestedFollowsByActor_Output
 
 	params := map[string]interface{}{}
 	params["actor"] = actor
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.getSuggestedFollowsByActor", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.graph.getSuggestedFollowsByActor", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/graphmuteActor.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // GraphMuteActor_Input is the input argument to a app.bsky.graph.muteActor call.
···
 }
 
 // GraphMuteActor calls the XRPC method "app.bsky.graph.muteActor".
-func GraphMuteActor(ctx context.Context, c *xrpc.Client, input *GraphMuteActor_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "app.bsky.graph.muteActor", nil, input, nil); err != nil {
+func GraphMuteActor(ctx context.Context, c util.LexClient, input *GraphMuteActor_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "app.bsky.graph.muteActor", nil, input, nil); err != nil {
 		return err
 	}
 

api/bsky/graphmuteActorList.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // GraphMuteActorList_Input is the input argument to a app.bsky.graph.muteActorList call.
···
 }
 
 // GraphMuteActorList calls the XRPC method "app.bsky.graph.muteActorList".
-func GraphMuteActorList(ctx context.Context, c *xrpc.Client, input *GraphMuteActorList_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "app.bsky.graph.muteActorList", nil, input, nil); err != nil {
+func GraphMuteActorList(ctx context.Context, c util.LexClient, input *GraphMuteActorList_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "app.bsky.graph.muteActorList", nil, input, nil); err != nil {
 		return err
 	}
 

api/bsky/graphmuteThread.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // GraphMuteThread_Input is the input argument to a app.bsky.graph.muteThread call.
···
 }
 
 // GraphMuteThread calls the XRPC method "app.bsky.graph.muteThread".
-func GraphMuteThread(ctx context.Context, c *xrpc.Client, input *GraphMuteThread_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "app.bsky.graph.muteThread", nil, input, nil); err != nil {
+func GraphMuteThread(ctx context.Context, c util.LexClient, input *GraphMuteThread_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "app.bsky.graph.muteThread", nil, input, nil); err != nil {
 		return err
 	}
 

api/bsky/graphsearchStarterPacks.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // GraphSearchStarterPacks_Output is the output of a app.bsky.graph.searchStarterPacks call.
···
 // GraphSearchStarterPacks calls the XRPC method "app.bsky.graph.searchStarterPacks".
 //
 // q: Search query string. Syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended.
-func GraphSearchStarterPacks(ctx context.Context, c *xrpc.Client, cursor string, limit int64, q string) (*GraphSearchStarterPacks_Output, error) {
+func GraphSearchStarterPacks(ctx context.Context, c util.LexClient, cursor string, limit int64, q string) (*GraphSearchStarterPacks_Output, error) {
 	var out GraphSearchStarterPacks_Output
 
 	params := map[string]interface{}{}
···
 		params["limit"] = limit
 	}
 	params["q"] = q
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.graph.searchStarterPacks", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.graph.searchStarterPacks", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/graphunmuteActor.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // GraphUnmuteActor_Input is the input argument to a app.bsky.graph.unmuteActor call.
···
 }
 
 // GraphUnmuteActor calls the XRPC method "app.bsky.graph.unmuteActor".
-func GraphUnmuteActor(ctx context.Context, c *xrpc.Client, input *GraphUnmuteActor_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "app.bsky.graph.unmuteActor", nil, input, nil); err != nil {
+func GraphUnmuteActor(ctx context.Context, c util.LexClient, input *GraphUnmuteActor_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "app.bsky.graph.unmuteActor", nil, input, nil); err != nil {
 		return err
 	}
 

api/bsky/graphunmuteActorList.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // GraphUnmuteActorList_Input is the input argument to a app.bsky.graph.unmuteActorList call.
···
 }
 
 // GraphUnmuteActorList calls the XRPC method "app.bsky.graph.unmuteActorList".
-func GraphUnmuteActorList(ctx context.Context, c *xrpc.Client, input *GraphUnmuteActorList_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "app.bsky.graph.unmuteActorList", nil, input, nil); err != nil {
+func GraphUnmuteActorList(ctx context.Context, c util.LexClient, input *GraphUnmuteActorList_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "app.bsky.graph.unmuteActorList", nil, input, nil); err != nil {
 		return err
 	}
 

api/bsky/graphunmuteThread.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // GraphUnmuteThread_Input is the input argument to a app.bsky.graph.unmuteThread call.
···
 }
 
 // GraphUnmuteThread calls the XRPC method "app.bsky.graph.unmuteThread".
-func GraphUnmuteThread(ctx context.Context, c *xrpc.Client, input *GraphUnmuteThread_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "app.bsky.graph.unmuteThread", nil, input, nil); err != nil {
+func GraphUnmuteThread(ctx context.Context, c util.LexClient, input *GraphUnmuteThread_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "app.bsky.graph.unmuteThread", nil, input, nil); err != nil {
 		return err
 	}
 

api/bsky/labelergetServices.go

···
 	"fmt"
 
 	"github.com/bluesky-social/indigo/lex/util"
-	"github.com/bluesky-social/indigo/xrpc"
 )
 
 // LabelerGetServices_Output is the output of a app.bsky.labeler.getServices call.
···
 }
 
 // LabelerGetServices calls the XRPC method "app.bsky.labeler.getServices".
-func LabelerGetServices(ctx context.Context, c *xrpc.Client, detailed bool, dids []string) (*LabelerGetServices_Output, error) {
+func LabelerGetServices(ctx context.Context, c util.LexClient, detailed bool, dids []string) (*LabelerGetServices_Output, error) {
 	var out LabelerGetServices_Output
 
 	params := map[string]interface{}{}
···
 		params["detailed"] = detailed
 	}
 	params["dids"] = dids
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.labeler.getServices", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.labeler.getServices", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/notificationgetUnreadCount.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // NotificationGetUnreadCount_Output is the output of a app.bsky.notification.getUnreadCount call.
···
 }
 
 // NotificationGetUnreadCount calls the XRPC method "app.bsky.notification.getUnreadCount".
-func NotificationGetUnreadCount(ctx context.Context, c *xrpc.Client, priority bool, seenAt string) (*NotificationGetUnreadCount_Output, error) {
+func NotificationGetUnreadCount(ctx context.Context, c util.LexClient, priority bool, seenAt string) (*NotificationGetUnreadCount_Output, error) {
 	var out NotificationGetUnreadCount_Output
 
 	params := map[string]interface{}{}
···
 	if seenAt != "" {
 		params["seenAt"] = seenAt
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.notification.getUnreadCount", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.notification.getUnreadCount", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/notificationlistNotifications.go

···
 
 	comatprototypes "github.com/bluesky-social/indigo/api/atproto"
 	"github.com/bluesky-social/indigo/lex/util"
-	"github.com/bluesky-social/indigo/xrpc"
 )
 
 // NotificationListNotifications_Notification is a "notification" in the app.bsky.notification.listNotifications schema.
···
 // NotificationListNotifications calls the XRPC method "app.bsky.notification.listNotifications".
 //
 // reasons: Notification reasons to include in response.
-func NotificationListNotifications(ctx context.Context, c *xrpc.Client, cursor string, limit int64, priority bool, reasons []string, seenAt string) (*NotificationListNotifications_Output, error) {
+func NotificationListNotifications(ctx context.Context, c util.LexClient, cursor string, limit int64, priority bool, reasons []string, seenAt string) (*NotificationListNotifications_Output, error) {
 	var out NotificationListNotifications_Output
 
 	params := map[string]interface{}{}
···
 	if seenAt != "" {
 		params["seenAt"] = seenAt
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.notification.listNotifications", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.notification.listNotifications", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/notificationputPreferences.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // NotificationPutPreferences_Input is the input argument to a app.bsky.notification.putPreferences call.
···
 }
 
 // NotificationPutPreferences calls the XRPC method "app.bsky.notification.putPreferences".
-func NotificationPutPreferences(ctx context.Context, c *xrpc.Client, input *NotificationPutPreferences_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "app.bsky.notification.putPreferences", nil, input, nil); err != nil {
+func NotificationPutPreferences(ctx context.Context, c util.LexClient, input *NotificationPutPreferences_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "app.bsky.notification.putPreferences", nil, input, nil); err != nil {
 		return err
 	}
 

api/bsky/notificationregisterPush.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // NotificationRegisterPush_Input is the input argument to a app.bsky.notification.registerPush call.
···
 }
 
 // NotificationRegisterPush calls the XRPC method "app.bsky.notification.registerPush".
-func NotificationRegisterPush(ctx context.Context, c *xrpc.Client, input *NotificationRegisterPush_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "app.bsky.notification.registerPush", nil, input, nil); err != nil {
+func NotificationRegisterPush(ctx context.Context, c util.LexClient, input *NotificationRegisterPush_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "app.bsky.notification.registerPush", nil, input, nil); err != nil {
 		return err
 	}
 

api/bsky/notificationupdateSeen.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // NotificationUpdateSeen_Input is the input argument to a app.bsky.notification.updateSeen call.
···
 }
 
 // NotificationUpdateSeen calls the XRPC method "app.bsky.notification.updateSeen".
-func NotificationUpdateSeen(ctx context.Context, c *xrpc.Client, input *NotificationUpdateSeen_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "app.bsky.notification.updateSeen", nil, input, nil); err != nil {
+func NotificationUpdateSeen(ctx context.Context, c util.LexClient, input *NotificationUpdateSeen_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "app.bsky.notification.updateSeen", nil, input, nil); err != nil {
 		return err
 	}
 

api/bsky/unspeccedgetConfig.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // UnspeccedGetConfig_LiveNowConfig is a "liveNowConfig" in the app.bsky.unspecced.getConfig schema.
···
 }
 
 // UnspeccedGetConfig calls the XRPC method "app.bsky.unspecced.getConfig".
-func UnspeccedGetConfig(ctx context.Context, c *xrpc.Client) (*UnspeccedGetConfig_Output, error) {
+func UnspeccedGetConfig(ctx context.Context, c util.LexClient) (*UnspeccedGetConfig_Output, error) {
 	var out UnspeccedGetConfig_Output
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.getConfig", nil, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.unspecced.getConfig", nil, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/unspeccedgetPopularFeedGenerators.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // UnspeccedGetPopularFeedGenerators_Output is the output of a app.bsky.unspecced.getPopularFeedGenerators call.
···
 }
 
 // UnspeccedGetPopularFeedGenerators calls the XRPC method "app.bsky.unspecced.getPopularFeedGenerators".
-func UnspeccedGetPopularFeedGenerators(ctx context.Context, c *xrpc.Client, cursor string, limit int64, query string) (*UnspeccedGetPopularFeedGenerators_Output, error) {
+func UnspeccedGetPopularFeedGenerators(ctx context.Context, c util.LexClient, cursor string, limit int64, query string) (*UnspeccedGetPopularFeedGenerators_Output, error) {
 	var out UnspeccedGetPopularFeedGenerators_Output
 
 	params := map[string]interface{}{}
···
 	if query != "" {
 		params["query"] = query
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.getPopularFeedGenerators", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.unspecced.getPopularFeedGenerators", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/unspeccedgetSuggestedFeeds.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // UnspeccedGetSuggestedFeeds_Output is the output of a app.bsky.unspecced.getSuggestedFeeds call.
···
 }
 
 // UnspeccedGetSuggestedFeeds calls the XRPC method "app.bsky.unspecced.getSuggestedFeeds".
-func UnspeccedGetSuggestedFeeds(ctx context.Context, c *xrpc.Client, limit int64) (*UnspeccedGetSuggestedFeeds_Output, error) {
+func UnspeccedGetSuggestedFeeds(ctx context.Context, c util.LexClient, limit int64) (*UnspeccedGetSuggestedFeeds_Output, error) {
 	var out UnspeccedGetSuggestedFeeds_Output
 
 	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 {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.unspecced.getSuggestedFeeds", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/unspeccedgetSuggestedFeedsSkeleton.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // UnspeccedGetSuggestedFeedsSkeleton_Output is the output of a app.bsky.unspecced.getSuggestedFeedsSkeleton call.
···
 // UnspeccedGetSuggestedFeedsSkeleton calls the XRPC method "app.bsky.unspecced.getSuggestedFeedsSkeleton".
 //
 // viewer: DID of the account making the request (not included for public/unauthenticated queries).
-func UnspeccedGetSuggestedFeedsSkeleton(ctx context.Context, c *xrpc.Client, limit int64, viewer string) (*UnspeccedGetSuggestedFeedsSkeleton_Output, error) {
+func UnspeccedGetSuggestedFeedsSkeleton(ctx context.Context, c util.LexClient, limit int64, viewer string) (*UnspeccedGetSuggestedFeedsSkeleton_Output, error) {
 	var out UnspeccedGetSuggestedFeedsSkeleton_Output
 
 	params := map[string]interface{}{}
···
 	if viewer != "" {
 		params["viewer"] = viewer
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.getSuggestedFeedsSkeleton", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.unspecced.getSuggestedFeedsSkeleton", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/unspeccedgetSuggestedStarterPacks.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // UnspeccedGetSuggestedStarterPacks_Output is the output of a app.bsky.unspecced.getSuggestedStarterPacks call.
···
 }
 
 // UnspeccedGetSuggestedStarterPacks calls the XRPC method "app.bsky.unspecced.getSuggestedStarterPacks".
-func UnspeccedGetSuggestedStarterPacks(ctx context.Context, c *xrpc.Client, limit int64) (*UnspeccedGetSuggestedStarterPacks_Output, error) {
+func UnspeccedGetSuggestedStarterPacks(ctx context.Context, c util.LexClient, limit int64) (*UnspeccedGetSuggestedStarterPacks_Output, error) {
 	var out UnspeccedGetSuggestedStarterPacks_Output
 
 	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 {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.unspecced.getSuggestedStarterPacks", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/unspeccedgetSuggestedStarterPacksSkeleton.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // UnspeccedGetSuggestedStarterPacksSkeleton_Output is the output of a app.bsky.unspecced.getSuggestedStarterPacksSkeleton call.
···
 // UnspeccedGetSuggestedStarterPacksSkeleton calls the XRPC method "app.bsky.unspecced.getSuggestedStarterPacksSkeleton".
 //
 // viewer: DID of the account making the request (not included for public/unauthenticated queries).
-func UnspeccedGetSuggestedStarterPacksSkeleton(ctx context.Context, c *xrpc.Client, limit int64, viewer string) (*UnspeccedGetSuggestedStarterPacksSkeleton_Output, error) {
+func UnspeccedGetSuggestedStarterPacksSkeleton(ctx context.Context, c util.LexClient, limit int64, viewer string) (*UnspeccedGetSuggestedStarterPacksSkeleton_Output, error) {
 	var out UnspeccedGetSuggestedStarterPacksSkeleton_Output
 
 	params := map[string]interface{}{}
···
 	if viewer != "" {
 		params["viewer"] = viewer
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.getSuggestedStarterPacksSkeleton", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.unspecced.getSuggestedStarterPacksSkeleton", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/unspeccedgetSuggestedUsers.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // UnspeccedGetSuggestedUsers_Output is the output of a app.bsky.unspecced.getSuggestedUsers call.
···
 // UnspeccedGetSuggestedUsers calls the XRPC method "app.bsky.unspecced.getSuggestedUsers".
 //
 // category: Category of users to get suggestions for.
-func UnspeccedGetSuggestedUsers(ctx context.Context, c *xrpc.Client, category string, limit int64) (*UnspeccedGetSuggestedUsers_Output, error) {
+func UnspeccedGetSuggestedUsers(ctx context.Context, c util.LexClient, category string, limit int64) (*UnspeccedGetSuggestedUsers_Output, error) {
 	var out UnspeccedGetSuggestedUsers_Output
 
 	params := map[string]interface{}{}
···
 	if limit != 0 {
 		params["limit"] = limit
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.getSuggestedUsers", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.unspecced.getSuggestedUsers", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/unspeccedgetSuggestedUsersSkeleton.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // UnspeccedGetSuggestedUsersSkeleton_Output is the output of a app.bsky.unspecced.getSuggestedUsersSkeleton call.
···
 //
 // category: Category of users to get suggestions for.
 // viewer: DID of the account making the request (not included for public/unauthenticated queries).
-func UnspeccedGetSuggestedUsersSkeleton(ctx context.Context, c *xrpc.Client, category string, limit int64, viewer string) (*UnspeccedGetSuggestedUsersSkeleton_Output, error) {
+func UnspeccedGetSuggestedUsersSkeleton(ctx context.Context, c util.LexClient, category string, limit int64, viewer string) (*UnspeccedGetSuggestedUsersSkeleton_Output, error) {
 	var out UnspeccedGetSuggestedUsersSkeleton_Output
 
 	params := map[string]interface{}{}
···
 	if viewer != "" {
 		params["viewer"] = viewer
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.getSuggestedUsersSkeleton", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.unspecced.getSuggestedUsersSkeleton", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/unspeccedgetSuggestionsSkeleton.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // UnspeccedGetSuggestionsSkeleton_Output is the output of a app.bsky.unspecced.getSuggestionsSkeleton call.
···
 //
 // relativeToDid: DID of the account to get suggestions relative to. If not provided, suggestions will be based on the viewer.
 // viewer: DID of the account making the request (not included for public/unauthenticated queries). Used to boost followed accounts in ranking.
-func UnspeccedGetSuggestionsSkeleton(ctx context.Context, c *xrpc.Client, cursor string, limit int64, relativeToDid string, viewer string) (*UnspeccedGetSuggestionsSkeleton_Output, error) {
+func UnspeccedGetSuggestionsSkeleton(ctx context.Context, c util.LexClient, cursor string, limit int64, relativeToDid string, viewer string) (*UnspeccedGetSuggestionsSkeleton_Output, error) {
 	var out UnspeccedGetSuggestionsSkeleton_Output
 
 	params := map[string]interface{}{}
···
 	if viewer != "" {
 		params["viewer"] = viewer
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.getSuggestionsSkeleton", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.unspecced.getSuggestionsSkeleton", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/unspeccedgetTaggedSuggestions.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // UnspeccedGetTaggedSuggestions_Output is the output of a app.bsky.unspecced.getTaggedSuggestions call.
···
 }
 
 // UnspeccedGetTaggedSuggestions calls the XRPC method "app.bsky.unspecced.getTaggedSuggestions".
-func UnspeccedGetTaggedSuggestions(ctx context.Context, c *xrpc.Client) (*UnspeccedGetTaggedSuggestions_Output, error) {
+func UnspeccedGetTaggedSuggestions(ctx context.Context, c util.LexClient) (*UnspeccedGetTaggedSuggestions_Output, error) {
 	var out UnspeccedGetTaggedSuggestions_Output
 
 	params := map[string]interface{}{}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.getTaggedSuggestions", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.unspecced.getTaggedSuggestions", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/unspeccedgetTrendingTopics.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // UnspeccedGetTrendingTopics_Output is the output of a app.bsky.unspecced.getTrendingTopics call.
···
 // UnspeccedGetTrendingTopics calls the XRPC method "app.bsky.unspecced.getTrendingTopics".
 //
 // viewer: DID of the account making the request (not included for public/unauthenticated queries). Used to boost followed accounts in ranking.
-func UnspeccedGetTrendingTopics(ctx context.Context, c *xrpc.Client, limit int64, viewer string) (*UnspeccedGetTrendingTopics_Output, error) {
+func UnspeccedGetTrendingTopics(ctx context.Context, c util.LexClient, limit int64, viewer string) (*UnspeccedGetTrendingTopics_Output, error) {
 	var out UnspeccedGetTrendingTopics_Output
 
 	params := map[string]interface{}{}
···
 	if viewer != "" {
 		params["viewer"] = viewer
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.getTrendingTopics", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.unspecced.getTrendingTopics", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/unspeccedgetTrends.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // UnspeccedGetTrends_Output is the output of a app.bsky.unspecced.getTrends call.
···
 }
 
 // UnspeccedGetTrends calls the XRPC method "app.bsky.unspecced.getTrends".
-func UnspeccedGetTrends(ctx context.Context, c *xrpc.Client, limit int64) (*UnspeccedGetTrends_Output, error) {
+func UnspeccedGetTrends(ctx context.Context, c util.LexClient, limit int64) (*UnspeccedGetTrends_Output, error) {
 	var out UnspeccedGetTrends_Output
 
 	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 {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.unspecced.getTrends", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/unspeccedgetTrendsSkeleton.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // UnspeccedGetTrendsSkeleton_Output is the output of a app.bsky.unspecced.getTrendsSkeleton call.
···
 // UnspeccedGetTrendsSkeleton calls the XRPC method "app.bsky.unspecced.getTrendsSkeleton".
 //
 // viewer: DID of the account making the request (not included for public/unauthenticated queries).
-func UnspeccedGetTrendsSkeleton(ctx context.Context, c *xrpc.Client, limit int64, viewer string) (*UnspeccedGetTrendsSkeleton_Output, error) {
+func UnspeccedGetTrendsSkeleton(ctx context.Context, c util.LexClient, limit int64, viewer string) (*UnspeccedGetTrendsSkeleton_Output, error) {
 	var out UnspeccedGetTrendsSkeleton_Output
 
 	params := map[string]interface{}{}
···
 	if viewer != "" {
 		params["viewer"] = viewer
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.getTrendsSkeleton", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.unspecced.getTrendsSkeleton", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/unspeccedsearchActorsSkeleton.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // UnspeccedSearchActorsSkeleton_Output is the output of a app.bsky.unspecced.searchActorsSkeleton call.
···
 // q: Search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended. For typeahead search, only simple term match is supported, not full syntax.
 // typeahead: If true, acts as fast/simple 'typeahead' query.
 // viewer: DID of the account making the request (not included for public/unauthenticated queries). Used to boost followed accounts in ranking.
-func UnspeccedSearchActorsSkeleton(ctx context.Context, c *xrpc.Client, cursor string, limit int64, q string, typeahead bool, viewer string) (*UnspeccedSearchActorsSkeleton_Output, error) {
+func UnspeccedSearchActorsSkeleton(ctx context.Context, c util.LexClient, cursor string, limit int64, q string, typeahead bool, viewer string) (*UnspeccedSearchActorsSkeleton_Output, error) {
 	var out UnspeccedSearchActorsSkeleton_Output
 
 	params := map[string]interface{}{}
···
 	if viewer != "" {
 		params["viewer"] = viewer
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.searchActorsSkeleton", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.unspecced.searchActorsSkeleton", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/unspeccedsearchPostsSkeleton.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // UnspeccedSearchPostsSkeleton_Output is the output of a app.bsky.unspecced.searchPostsSkeleton call.
···
 // until: Filter results for posts before the indicated datetime (not inclusive). Expected to use 'sortAt' timestamp, which may not match 'createdAt'. Can be a datetime, or just an ISO date (YYY-MM-DD).
 // url: Filter to posts with links (facet links or embeds) pointing to this URL. Server may apply URL normalization or fuzzy matching.
 // viewer: DID of the account making the request (not included for public/unauthenticated queries). Used for 'from:me' queries.
-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) {
+func UnspeccedSearchPostsSkeleton(ctx context.Context, c util.LexClient, 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{}{}
···
 	if viewer != "" {
 		params["viewer"] = viewer
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.searchPostsSkeleton", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.unspecced.searchPostsSkeleton", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/unspeccedsearchStarterPacksSkeleton.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // UnspeccedSearchStarterPacksSkeleton_Output is the output of a app.bsky.unspecced.searchStarterPacksSkeleton call.
···
 // cursor: Optional pagination mechanism; may not necessarily allow scrolling through entire result set.
 // q: Search query string; syntax, phrase, boolean, and faceting is unspecified, but Lucene query syntax is recommended.
 // viewer: DID of the account making the request (not included for public/unauthenticated queries).
-func UnspeccedSearchStarterPacksSkeleton(ctx context.Context, c *xrpc.Client, cursor string, limit int64, q string, viewer string) (*UnspeccedSearchStarterPacksSkeleton_Output, error) {
+func UnspeccedSearchStarterPacksSkeleton(ctx context.Context, c util.LexClient, cursor string, limit int64, q string, viewer string) (*UnspeccedSearchStarterPacksSkeleton_Output, error) {
 	var out UnspeccedSearchStarterPacksSkeleton_Output
 
 	params := map[string]interface{}{}
···
 	if viewer != "" {
 		params["viewer"] = viewer
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.searchStarterPacksSkeleton", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.unspecced.searchStarterPacksSkeleton", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/videogetJobStatus.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // VideoGetJobStatus_Output is the output of a app.bsky.video.getJobStatus call.
···
 }
 
 // VideoGetJobStatus calls the XRPC method "app.bsky.video.getJobStatus".
-func VideoGetJobStatus(ctx context.Context, c *xrpc.Client, jobId string) (*VideoGetJobStatus_Output, error) {
+func VideoGetJobStatus(ctx context.Context, c util.LexClient, jobId string) (*VideoGetJobStatus_Output, error) {
 	var out VideoGetJobStatus_Output
 
 	params := map[string]interface{}{}
 	params["jobId"] = jobId
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.video.getJobStatus", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.video.getJobStatus", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/videogetUploadLimits.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // VideoGetUploadLimits_Output is the output of a app.bsky.video.getUploadLimits call.
···
 }
 
 // VideoGetUploadLimits calls the XRPC method "app.bsky.video.getUploadLimits".
-func VideoGetUploadLimits(ctx context.Context, c *xrpc.Client) (*VideoGetUploadLimits_Output, error) {
+func VideoGetUploadLimits(ctx context.Context, c util.LexClient) (*VideoGetUploadLimits_Output, error) {
 	var out VideoGetUploadLimits_Output
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.video.getUploadLimits", nil, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.video.getUploadLimits", nil, nil, &out); err != nil {
 		return nil, err
 	}
 

api/bsky/videouploadVideo.go

···
 	"context"
 	"io"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // VideoUploadVideo_Output is the output of a app.bsky.video.uploadVideo call.
···
 }
 
 // VideoUploadVideo calls the XRPC method "app.bsky.video.uploadVideo".
-func VideoUploadVideo(ctx context.Context, c *xrpc.Client, input io.Reader) (*VideoUploadVideo_Output, error) {
+func VideoUploadVideo(ctx context.Context, c util.LexClient, input io.Reader) (*VideoUploadVideo_Output, error) {
 	var out VideoUploadVideo_Output
-	if err := c.Do(ctx, xrpc.Procedure, "video/mp4", "app.bsky.video.uploadVideo", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "video/mp4", "app.bsky.video.uploadVideo", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/chat/actordeleteAccount.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ActorDeleteAccount_Output is the output of a chat.bsky.actor.deleteAccount call.
···
 }
 
 // ActorDeleteAccount calls the XRPC method "chat.bsky.actor.deleteAccount".
-func ActorDeleteAccount(ctx context.Context, c *xrpc.Client) (*ActorDeleteAccount_Output, error) {
+func ActorDeleteAccount(ctx context.Context, c util.LexClient) (*ActorDeleteAccount_Output, error) {
 	var out ActorDeleteAccount_Output
-	if err := c.Do(ctx, xrpc.Procedure, "", "chat.bsky.actor.deleteAccount", nil, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "", "chat.bsky.actor.deleteAccount", nil, nil, &out); err != nil {
 		return nil, err
 	}
 

api/chat/actorexportAccountData.go

···
 	"bytes"
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ActorExportAccountData calls the XRPC method "chat.bsky.actor.exportAccountData".
-func ActorExportAccountData(ctx context.Context, c *xrpc.Client) ([]byte, error) {
+func ActorExportAccountData(ctx context.Context, c util.LexClient) ([]byte, error) {
 	buf := new(bytes.Buffer)
-	if err := c.Do(ctx, xrpc.Query, "", "chat.bsky.actor.exportAccountData", nil, nil, buf); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "chat.bsky.actor.exportAccountData", nil, nil, buf); err != nil {
 		return nil, err
 	}
 

api/chat/convoacceptConvo.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ConvoAcceptConvo_Input is the input argument to a chat.bsky.convo.acceptConvo call.
···
 }
 
 // ConvoAcceptConvo calls the XRPC method "chat.bsky.convo.acceptConvo".
-func ConvoAcceptConvo(ctx context.Context, c *xrpc.Client, input *ConvoAcceptConvo_Input) (*ConvoAcceptConvo_Output, error) {
+func ConvoAcceptConvo(ctx context.Context, c util.LexClient, input *ConvoAcceptConvo_Input) (*ConvoAcceptConvo_Output, error) {
 	var out ConvoAcceptConvo_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "chat.bsky.convo.acceptConvo", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "chat.bsky.convo.acceptConvo", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/chat/convoaddReaction.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ConvoAddReaction_Input is the input argument to a chat.bsky.convo.addReaction call.
···
 }
 
 // ConvoAddReaction calls the XRPC method "chat.bsky.convo.addReaction".
-func ConvoAddReaction(ctx context.Context, c *xrpc.Client, input *ConvoAddReaction_Input) (*ConvoAddReaction_Output, error) {
+func ConvoAddReaction(ctx context.Context, c util.LexClient, input *ConvoAddReaction_Input) (*ConvoAddReaction_Output, error) {
 	var out ConvoAddReaction_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "chat.bsky.convo.addReaction", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "chat.bsky.convo.addReaction", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/chat/convodeleteMessageForSelf.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ConvoDeleteMessageForSelf_Input is the input argument to a chat.bsky.convo.deleteMessageForSelf call.
···
 }
 
 // ConvoDeleteMessageForSelf calls the XRPC method "chat.bsky.convo.deleteMessageForSelf".
-func ConvoDeleteMessageForSelf(ctx context.Context, c *xrpc.Client, input *ConvoDeleteMessageForSelf_Input) (*ConvoDefs_DeletedMessageView, error) {
+func ConvoDeleteMessageForSelf(ctx context.Context, c util.LexClient, input *ConvoDeleteMessageForSelf_Input) (*ConvoDefs_DeletedMessageView, error) {
 	var out ConvoDefs_DeletedMessageView
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "chat.bsky.convo.deleteMessageForSelf", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "chat.bsky.convo.deleteMessageForSelf", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/chat/convogetConvo.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ConvoGetConvo_Output is the output of a chat.bsky.convo.getConvo call.
···
 }
 
 // ConvoGetConvo calls the XRPC method "chat.bsky.convo.getConvo".
-func ConvoGetConvo(ctx context.Context, c *xrpc.Client, convoId string) (*ConvoGetConvo_Output, error) {
+func ConvoGetConvo(ctx context.Context, c util.LexClient, convoId string) (*ConvoGetConvo_Output, error) {
 	var out ConvoGetConvo_Output
 
 	params := map[string]interface{}{}
 	params["convoId"] = convoId
-	if err := c.Do(ctx, xrpc.Query, "", "chat.bsky.convo.getConvo", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "chat.bsky.convo.getConvo", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/chat/convogetConvoAvailability.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ConvoGetConvoAvailability_Output is the output of a chat.bsky.convo.getConvoAvailability call.
···
 }
 
 // ConvoGetConvoAvailability calls the XRPC method "chat.bsky.convo.getConvoAvailability".
-func ConvoGetConvoAvailability(ctx context.Context, c *xrpc.Client, members []string) (*ConvoGetConvoAvailability_Output, error) {
+func ConvoGetConvoAvailability(ctx context.Context, c util.LexClient, members []string) (*ConvoGetConvoAvailability_Output, error) {
 	var out ConvoGetConvoAvailability_Output
 
 	params := map[string]interface{}{}
 	params["members"] = members
-	if err := c.Do(ctx, xrpc.Query, "", "chat.bsky.convo.getConvoAvailability", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "chat.bsky.convo.getConvoAvailability", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/chat/convogetConvoForMembers.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ConvoGetConvoForMembers_Output is the output of a chat.bsky.convo.getConvoForMembers call.
···
 }
 
 // ConvoGetConvoForMembers calls the XRPC method "chat.bsky.convo.getConvoForMembers".
-func ConvoGetConvoForMembers(ctx context.Context, c *xrpc.Client, members []string) (*ConvoGetConvoForMembers_Output, error) {
+func ConvoGetConvoForMembers(ctx context.Context, c util.LexClient, members []string) (*ConvoGetConvoForMembers_Output, error) {
 	var out ConvoGetConvoForMembers_Output
 
 	params := map[string]interface{}{}
 	params["members"] = members
-	if err := c.Do(ctx, xrpc.Query, "", "chat.bsky.convo.getConvoForMembers", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "chat.bsky.convo.getConvoForMembers", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/chat/convogetLog.go

···
 	"fmt"
 
 	"github.com/bluesky-social/indigo/lex/util"
-	"github.com/bluesky-social/indigo/xrpc"
 )
 
 // ConvoGetLog_Output is the output of a chat.bsky.convo.getLog call.
···
 }
 
 // ConvoGetLog calls the XRPC method "chat.bsky.convo.getLog".
-func ConvoGetLog(ctx context.Context, c *xrpc.Client, cursor string) (*ConvoGetLog_Output, error) {
+func ConvoGetLog(ctx context.Context, c util.LexClient, cursor string) (*ConvoGetLog_Output, error) {
 	var out ConvoGetLog_Output
 
 	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 {
+	if err := c.LexDo(ctx, util.Query, "", "chat.bsky.convo.getLog", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/chat/convogetMessages.go

···
 	"fmt"
 
 	"github.com/bluesky-social/indigo/lex/util"
-	"github.com/bluesky-social/indigo/xrpc"
 )
 
 // ConvoGetMessages_Output is the output of a chat.bsky.convo.getMessages call.
···
 }
 
 // ConvoGetMessages calls the XRPC method "chat.bsky.convo.getMessages".
-func ConvoGetMessages(ctx context.Context, c *xrpc.Client, convoId string, cursor string, limit int64) (*ConvoGetMessages_Output, error) {
+func ConvoGetMessages(ctx context.Context, c util.LexClient, convoId string, cursor string, limit int64) (*ConvoGetMessages_Output, error) {
 	var out ConvoGetMessages_Output
 
 	params := map[string]interface{}{}
···
 	if limit != 0 {
 		params["limit"] = limit
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "chat.bsky.convo.getMessages", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "chat.bsky.convo.getMessages", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/chat/convoleaveConvo.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ConvoLeaveConvo_Input is the input argument to a chat.bsky.convo.leaveConvo call.
···
 }
 
 // ConvoLeaveConvo calls the XRPC method "chat.bsky.convo.leaveConvo".
-func ConvoLeaveConvo(ctx context.Context, c *xrpc.Client, input *ConvoLeaveConvo_Input) (*ConvoLeaveConvo_Output, error) {
+func ConvoLeaveConvo(ctx context.Context, c util.LexClient, input *ConvoLeaveConvo_Input) (*ConvoLeaveConvo_Output, error) {
 	var out ConvoLeaveConvo_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "chat.bsky.convo.leaveConvo", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "chat.bsky.convo.leaveConvo", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/chat/convolistConvos.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ConvoListConvos_Output is the output of a chat.bsky.convo.listConvos call.
···
 }
 
 // ConvoListConvos calls the XRPC method "chat.bsky.convo.listConvos".
-func ConvoListConvos(ctx context.Context, c *xrpc.Client, cursor string, limit int64, readState string, status string) (*ConvoListConvos_Output, error) {
+func ConvoListConvos(ctx context.Context, c util.LexClient, cursor string, limit int64, readState string, status string) (*ConvoListConvos_Output, error) {
 	var out ConvoListConvos_Output
 
 	params := map[string]interface{}{}
···
 	if status != "" {
 		params["status"] = status
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "chat.bsky.convo.listConvos", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "chat.bsky.convo.listConvos", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/chat/convomuteConvo.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ConvoMuteConvo_Input is the input argument to a chat.bsky.convo.muteConvo call.
···
 }
 
 // ConvoMuteConvo calls the XRPC method "chat.bsky.convo.muteConvo".
-func ConvoMuteConvo(ctx context.Context, c *xrpc.Client, input *ConvoMuteConvo_Input) (*ConvoMuteConvo_Output, error) {
+func ConvoMuteConvo(ctx context.Context, c util.LexClient, input *ConvoMuteConvo_Input) (*ConvoMuteConvo_Output, error) {
 	var out ConvoMuteConvo_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "chat.bsky.convo.muteConvo", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "chat.bsky.convo.muteConvo", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/chat/convoremoveReaction.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ConvoRemoveReaction_Input is the input argument to a chat.bsky.convo.removeReaction call.
···
 }
 
 // ConvoRemoveReaction calls the XRPC method "chat.bsky.convo.removeReaction".
-func ConvoRemoveReaction(ctx context.Context, c *xrpc.Client, input *ConvoRemoveReaction_Input) (*ConvoRemoveReaction_Output, error) {
+func ConvoRemoveReaction(ctx context.Context, c util.LexClient, input *ConvoRemoveReaction_Input) (*ConvoRemoveReaction_Output, error) {
 	var out ConvoRemoveReaction_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "chat.bsky.convo.removeReaction", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "chat.bsky.convo.removeReaction", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/chat/convosendMessage.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ConvoSendMessage_Input is the input argument to a chat.bsky.convo.sendMessage call.
···
 }
 
 // ConvoSendMessage calls the XRPC method "chat.bsky.convo.sendMessage".
-func ConvoSendMessage(ctx context.Context, c *xrpc.Client, input *ConvoSendMessage_Input) (*ConvoDefs_MessageView, error) {
+func ConvoSendMessage(ctx context.Context, c util.LexClient, input *ConvoSendMessage_Input) (*ConvoDefs_MessageView, error) {
 	var out ConvoDefs_MessageView
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "chat.bsky.convo.sendMessage", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "chat.bsky.convo.sendMessage", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/chat/convosendMessageBatch.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ConvoSendMessageBatch_BatchItem is a "batchItem" in the chat.bsky.convo.sendMessageBatch schema.
···
 }
 
 // ConvoSendMessageBatch calls the XRPC method "chat.bsky.convo.sendMessageBatch".
-func ConvoSendMessageBatch(ctx context.Context, c *xrpc.Client, input *ConvoSendMessageBatch_Input) (*ConvoSendMessageBatch_Output, error) {
+func ConvoSendMessageBatch(ctx context.Context, c util.LexClient, input *ConvoSendMessageBatch_Input) (*ConvoSendMessageBatch_Output, error) {
 	var out ConvoSendMessageBatch_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "chat.bsky.convo.sendMessageBatch", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "chat.bsky.convo.sendMessageBatch", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/chat/convounmuteConvo.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ConvoUnmuteConvo_Input is the input argument to a chat.bsky.convo.unmuteConvo call.
···
 }
 
 // ConvoUnmuteConvo calls the XRPC method "chat.bsky.convo.unmuteConvo".
-func ConvoUnmuteConvo(ctx context.Context, c *xrpc.Client, input *ConvoUnmuteConvo_Input) (*ConvoUnmuteConvo_Output, error) {
+func ConvoUnmuteConvo(ctx context.Context, c util.LexClient, input *ConvoUnmuteConvo_Input) (*ConvoUnmuteConvo_Output, error) {
 	var out ConvoUnmuteConvo_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "chat.bsky.convo.unmuteConvo", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "chat.bsky.convo.unmuteConvo", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/chat/convoupdateAllRead.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ConvoUpdateAllRead_Input is the input argument to a chat.bsky.convo.updateAllRead call.
···
 }
 
 // ConvoUpdateAllRead calls the XRPC method "chat.bsky.convo.updateAllRead".
-func ConvoUpdateAllRead(ctx context.Context, c *xrpc.Client, input *ConvoUpdateAllRead_Input) (*ConvoUpdateAllRead_Output, error) {
+func ConvoUpdateAllRead(ctx context.Context, c util.LexClient, input *ConvoUpdateAllRead_Input) (*ConvoUpdateAllRead_Output, error) {
 	var out ConvoUpdateAllRead_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "chat.bsky.convo.updateAllRead", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "chat.bsky.convo.updateAllRead", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/chat/convoupdateRead.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ConvoUpdateRead_Input is the input argument to a chat.bsky.convo.updateRead call.
···
 }
 
 // ConvoUpdateRead calls the XRPC method "chat.bsky.convo.updateRead".
-func ConvoUpdateRead(ctx context.Context, c *xrpc.Client, input *ConvoUpdateRead_Input) (*ConvoUpdateRead_Output, error) {
+func ConvoUpdateRead(ctx context.Context, c util.LexClient, input *ConvoUpdateRead_Input) (*ConvoUpdateRead_Output, error) {
 	var out ConvoUpdateRead_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "chat.bsky.convo.updateRead", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "chat.bsky.convo.updateRead", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/chat/moderationgetActorMetadata.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ModerationGetActorMetadata_Metadata is a "metadata" in the chat.bsky.moderation.getActorMetadata schema.
···
 }
 
 // ModerationGetActorMetadata calls the XRPC method "chat.bsky.moderation.getActorMetadata".
-func ModerationGetActorMetadata(ctx context.Context, c *xrpc.Client, actor string) (*ModerationGetActorMetadata_Output, error) {
+func ModerationGetActorMetadata(ctx context.Context, c util.LexClient, actor string) (*ModerationGetActorMetadata_Output, error) {
 	var out ModerationGetActorMetadata_Output
 
 	params := map[string]interface{}{}
 	params["actor"] = actor
-	if err := c.Do(ctx, xrpc.Query, "", "chat.bsky.moderation.getActorMetadata", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "chat.bsky.moderation.getActorMetadata", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/chat/moderationgetMessageContext.go

···
 	"fmt"
 
 	"github.com/bluesky-social/indigo/lex/util"
-	"github.com/bluesky-social/indigo/xrpc"
 )
 
 // ModerationGetMessageContext_Output is the output of a chat.bsky.moderation.getMessageContext call.
···
 // ModerationGetMessageContext calls the XRPC method "chat.bsky.moderation.getMessageContext".
 //
 // convoId: Conversation that the message is from. NOTE: this field will eventually be required.
-func ModerationGetMessageContext(ctx context.Context, c *xrpc.Client, after int64, before int64, convoId string, messageId string) (*ModerationGetMessageContext_Output, error) {
+func ModerationGetMessageContext(ctx context.Context, c util.LexClient, after int64, before int64, convoId string, messageId string) (*ModerationGetMessageContext_Output, error) {
 	var out ModerationGetMessageContext_Output
 
 	params := map[string]interface{}{}
···
 		params["convoId"] = convoId
 	}
 	params["messageId"] = messageId
-	if err := c.Do(ctx, xrpc.Query, "", "chat.bsky.moderation.getMessageContext", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "chat.bsky.moderation.getMessageContext", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/chat/moderationupdateActorAccess.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ModerationUpdateActorAccess_Input is the input argument to a chat.bsky.moderation.updateActorAccess call.
···
 }
 
 // ModerationUpdateActorAccess calls the XRPC method "chat.bsky.moderation.updateActorAccess".
-func ModerationUpdateActorAccess(ctx context.Context, c *xrpc.Client, input *ModerationUpdateActorAccess_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "chat.bsky.moderation.updateActorAccess", nil, input, nil); err != nil {
+func ModerationUpdateActorAccess(ctx context.Context, c util.LexClient, input *ModerationUpdateActorAccess_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "chat.bsky.moderation.updateActorAccess", nil, input, nil); err != nil {
 		return err
 	}
 

api/ozone/communicationcreateTemplate.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // CommunicationCreateTemplate_Input is the input argument to a tools.ozone.communication.createTemplate call.
···
 }
 
 // CommunicationCreateTemplate calls the XRPC method "tools.ozone.communication.createTemplate".
-func CommunicationCreateTemplate(ctx context.Context, c *xrpc.Client, input *CommunicationCreateTemplate_Input) (*CommunicationDefs_TemplateView, error) {
+func CommunicationCreateTemplate(ctx context.Context, c util.LexClient, input *CommunicationCreateTemplate_Input) (*CommunicationDefs_TemplateView, error) {
 	var out CommunicationDefs_TemplateView
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "tools.ozone.communication.createTemplate", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "tools.ozone.communication.createTemplate", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/communicationdeleteTemplate.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // CommunicationDeleteTemplate_Input is the input argument to a tools.ozone.communication.deleteTemplate call.
···
 }
 
 // CommunicationDeleteTemplate calls the XRPC method "tools.ozone.communication.deleteTemplate".
-func CommunicationDeleteTemplate(ctx context.Context, c *xrpc.Client, input *CommunicationDeleteTemplate_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "tools.ozone.communication.deleteTemplate", nil, input, nil); err != nil {
+func CommunicationDeleteTemplate(ctx context.Context, c util.LexClient, input *CommunicationDeleteTemplate_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "tools.ozone.communication.deleteTemplate", nil, input, nil); err != nil {
 		return err
 	}
 

api/ozone/communicationlistTemplates.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // CommunicationListTemplates_Output is the output of a tools.ozone.communication.listTemplates call.
···
 }
 
 // CommunicationListTemplates calls the XRPC method "tools.ozone.communication.listTemplates".
-func CommunicationListTemplates(ctx context.Context, c *xrpc.Client) (*CommunicationListTemplates_Output, error) {
+func CommunicationListTemplates(ctx context.Context, c util.LexClient) (*CommunicationListTemplates_Output, error) {
 	var out CommunicationListTemplates_Output
-	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.communication.listTemplates", nil, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "tools.ozone.communication.listTemplates", nil, nil, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/communicationupdateTemplate.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // CommunicationUpdateTemplate_Input is the input argument to a tools.ozone.communication.updateTemplate call.
···
 }
 
 // CommunicationUpdateTemplate calls the XRPC method "tools.ozone.communication.updateTemplate".
-func CommunicationUpdateTemplate(ctx context.Context, c *xrpc.Client, input *CommunicationUpdateTemplate_Input) (*CommunicationDefs_TemplateView, error) {
+func CommunicationUpdateTemplate(ctx context.Context, c util.LexClient, input *CommunicationUpdateTemplate_Input) (*CommunicationDefs_TemplateView, error) {
 	var out CommunicationDefs_TemplateView
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "tools.ozone.communication.updateTemplate", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "tools.ozone.communication.updateTemplate", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/hostinggetAccountHistory.go

···
 	"fmt"
 
 	"github.com/bluesky-social/indigo/lex/util"
-	"github.com/bluesky-social/indigo/xrpc"
 )
 
 // HostingGetAccountHistory_AccountCreated is a "accountCreated" in the tools.ozone.hosting.getAccountHistory schema.
···
 }
 
 // HostingGetAccountHistory calls the XRPC method "tools.ozone.hosting.getAccountHistory".
-func HostingGetAccountHistory(ctx context.Context, c *xrpc.Client, cursor string, did string, events []string, limit int64) (*HostingGetAccountHistory_Output, error) {
+func HostingGetAccountHistory(ctx context.Context, c util.LexClient, cursor string, did string, events []string, limit int64) (*HostingGetAccountHistory_Output, error) {
 	var out HostingGetAccountHistory_Output
 
 	params := map[string]interface{}{}
···
 	if limit != 0 {
 		params["limit"] = limit
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.hosting.getAccountHistory", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "tools.ozone.hosting.getAccountHistory", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/moderationemitEvent.go

···
 
 	comatprototypes "github.com/bluesky-social/indigo/api/atproto"
 	"github.com/bluesky-social/indigo/lex/util"
-	"github.com/bluesky-social/indigo/xrpc"
 )
 
 // ModerationEmitEvent_Input is the input argument to a tools.ozone.moderation.emitEvent call.
···
 }
 
 // ModerationEmitEvent calls the XRPC method "tools.ozone.moderation.emitEvent".
-func ModerationEmitEvent(ctx context.Context, c *xrpc.Client, input *ModerationEmitEvent_Input) (*ModerationDefs_ModEventView, error) {
+func ModerationEmitEvent(ctx context.Context, c util.LexClient, input *ModerationEmitEvent_Input) (*ModerationDefs_ModEventView, error) {
 	var out ModerationDefs_ModEventView
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "tools.ozone.moderation.emitEvent", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "tools.ozone.moderation.emitEvent", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/moderationgetEvent.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ModerationGetEvent calls the XRPC method "tools.ozone.moderation.getEvent".
-func ModerationGetEvent(ctx context.Context, c *xrpc.Client, id int64) (*ModerationDefs_ModEventViewDetail, error) {
+func ModerationGetEvent(ctx context.Context, c util.LexClient, id int64) (*ModerationDefs_ModEventViewDetail, error) {
 	var out ModerationDefs_ModEventViewDetail
 
 	params := map[string]interface{}{}
 	params["id"] = id
-	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.moderation.getEvent", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "tools.ozone.moderation.getEvent", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/moderationgetRecord.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ModerationGetRecord calls the XRPC method "tools.ozone.moderation.getRecord".
-func ModerationGetRecord(ctx context.Context, c *xrpc.Client, cid string, uri string) (*ModerationDefs_RecordViewDetail, error) {
+func ModerationGetRecord(ctx context.Context, c util.LexClient, cid string, uri string) (*ModerationDefs_RecordViewDetail, error) {
 	var out ModerationDefs_RecordViewDetail
 
 	params := map[string]interface{}{}
···
 		params["cid"] = cid
 	}
 	params["uri"] = uri
-	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.moderation.getRecord", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "tools.ozone.moderation.getRecord", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/moderationgetRecords.go

···
 	"fmt"
 
 	"github.com/bluesky-social/indigo/lex/util"
-	"github.com/bluesky-social/indigo/xrpc"
 )
 
 // ModerationGetRecords_Output is the output of a tools.ozone.moderation.getRecords call.
···
 }
 
 // ModerationGetRecords calls the XRPC method "tools.ozone.moderation.getRecords".
-func ModerationGetRecords(ctx context.Context, c *xrpc.Client, uris []string) (*ModerationGetRecords_Output, error) {
+func ModerationGetRecords(ctx context.Context, c util.LexClient, uris []string) (*ModerationGetRecords_Output, error) {
 	var out ModerationGetRecords_Output
 
 	params := map[string]interface{}{}
 	params["uris"] = uris
-	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.moderation.getRecords", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "tools.ozone.moderation.getRecords", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/moderationgetRepo.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ModerationGetRepo calls the XRPC method "tools.ozone.moderation.getRepo".
-func ModerationGetRepo(ctx context.Context, c *xrpc.Client, did string) (*ModerationDefs_RepoViewDetail, error) {
+func ModerationGetRepo(ctx context.Context, c util.LexClient, did string) (*ModerationDefs_RepoViewDetail, error) {
 	var out ModerationDefs_RepoViewDetail
 
 	params := map[string]interface{}{}
 	params["did"] = did
-	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.moderation.getRepo", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "tools.ozone.moderation.getRepo", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/moderationgetReporterStats.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ModerationGetReporterStats_Output is the output of a tools.ozone.moderation.getReporterStats call.
···
 }
 
 // ModerationGetReporterStats calls the XRPC method "tools.ozone.moderation.getReporterStats".
-func ModerationGetReporterStats(ctx context.Context, c *xrpc.Client, dids []string) (*ModerationGetReporterStats_Output, error) {
+func ModerationGetReporterStats(ctx context.Context, c util.LexClient, dids []string) (*ModerationGetReporterStats_Output, error) {
 	var out ModerationGetReporterStats_Output
 
 	params := map[string]interface{}{}
 	params["dids"] = dids
-	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.moderation.getReporterStats", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "tools.ozone.moderation.getReporterStats", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/moderationgetRepos.go

···
 	"fmt"
 
 	"github.com/bluesky-social/indigo/lex/util"
-	"github.com/bluesky-social/indigo/xrpc"
 )
 
 // ModerationGetRepos_Output is the output of a tools.ozone.moderation.getRepos call.
···
 }
 
 // ModerationGetRepos calls the XRPC method "tools.ozone.moderation.getRepos".
-func ModerationGetRepos(ctx context.Context, c *xrpc.Client, dids []string) (*ModerationGetRepos_Output, error) {
+func ModerationGetRepos(ctx context.Context, c util.LexClient, dids []string) (*ModerationGetRepos_Output, error) {
 	var out ModerationGetRepos_Output
 
 	params := map[string]interface{}{}
 	params["dids"] = dids
-	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.moderation.getRepos", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "tools.ozone.moderation.getRepos", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/moderationgetSubjects.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ModerationGetSubjects_Output is the output of a tools.ozone.moderation.getSubjects call.
···
 }
 
 // ModerationGetSubjects calls the XRPC method "tools.ozone.moderation.getSubjects".
-func ModerationGetSubjects(ctx context.Context, c *xrpc.Client, subjects []string) (*ModerationGetSubjects_Output, error) {
+func ModerationGetSubjects(ctx context.Context, c util.LexClient, subjects []string) (*ModerationGetSubjects_Output, error) {
 	var out ModerationGetSubjects_Output
 
 	params := map[string]interface{}{}
 	params["subjects"] = subjects
-	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.moderation.getSubjects", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "tools.ozone.moderation.getSubjects", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/moderationqueryEvents.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ModerationQueryEvents_Output is the output of a tools.ozone.moderation.queryEvents call.
···
 // sortDirection: Sort direction for the events. Defaults to descending order of created at timestamp.
 // subjectType: If specified, only events where the subject is of the given type (account or record) will be returned. When this is set to 'account' the 'collections' parameter will be ignored. When includeAllUserRecords or subject is set, this will be ignored.
 // types: The types of events (fully qualified string in the format of tools.ozone.moderation.defs#modEvent<name>) to filter by. If not specified, all events are returned.
-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) {
+func ModerationQueryEvents(ctx context.Context, c util.LexClient, 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{}{}
···
 	if len(types) != 0 {
 		params["types"] = types
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.moderation.queryEvents", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "tools.ozone.moderation.queryEvents", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/moderationqueryStatuses.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ModerationQueryStatuses_Output is the output of a tools.ozone.moderation.queryStatuses call.
···
 // subject: The subject to get the status for.
 // subjectType: If specified, subjects of the given type (account or record) will be returned. When this is set to 'account' the 'collections' parameter will be ignored. When includeAllUserRecords or subject is set, this will be ignored.
 // takendown: Get subjects that were taken down
-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) {
+func ModerationQueryStatuses(ctx context.Context, c util.LexClient, 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{}{}
···
 	if takendown {
 		params["takendown"] = takendown
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.moderation.queryStatuses", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "tools.ozone.moderation.queryStatuses", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/moderationsearchRepos.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ModerationSearchRepos_Output is the output of a tools.ozone.moderation.searchRepos call.
···
 // ModerationSearchRepos calls the XRPC method "tools.ozone.moderation.searchRepos".
 //
 // term: DEPRECATED: use 'q' instead
-func ModerationSearchRepos(ctx context.Context, c *xrpc.Client, cursor string, limit int64, q string, term string) (*ModerationSearchRepos_Output, error) {
+func ModerationSearchRepos(ctx context.Context, c util.LexClient, cursor string, limit int64, q string, term string) (*ModerationSearchRepos_Output, error) {
 	var out ModerationSearchRepos_Output
 
 	params := map[string]interface{}{}
···
 	if term != "" {
 		params["term"] = term
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.moderation.searchRepos", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "tools.ozone.moderation.searchRepos", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/servergetConfig.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ServerGetConfig_Output is the output of a tools.ozone.server.getConfig call.
···
 }
 
 // ServerGetConfig calls the XRPC method "tools.ozone.server.getConfig".
-func ServerGetConfig(ctx context.Context, c *xrpc.Client) (*ServerGetConfig_Output, error) {
+func ServerGetConfig(ctx context.Context, c util.LexClient) (*ServerGetConfig_Output, error) {
 	var out ServerGetConfig_Output
-	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.server.getConfig", nil, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "tools.ozone.server.getConfig", nil, nil, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/setaddValues.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // SetAddValues_Input is the input argument to a tools.ozone.set.addValues call.
···
 }
 
 // SetAddValues calls the XRPC method "tools.ozone.set.addValues".
-func SetAddValues(ctx context.Context, c *xrpc.Client, input *SetAddValues_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "tools.ozone.set.addValues", nil, input, nil); err != nil {
+func SetAddValues(ctx context.Context, c util.LexClient, input *SetAddValues_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "tools.ozone.set.addValues", nil, input, nil); err != nil {
 		return err
 	}
 

api/ozone/setdeleteSet.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // SetDeleteSet_Input is the input argument to a tools.ozone.set.deleteSet call.
···
 }
 
 // SetDeleteSet calls the XRPC method "tools.ozone.set.deleteSet".
-func SetDeleteSet(ctx context.Context, c *xrpc.Client, input *SetDeleteSet_Input) (*SetDeleteSet_Output, error) {
+func SetDeleteSet(ctx context.Context, c util.LexClient, input *SetDeleteSet_Input) (*SetDeleteSet_Output, error) {
 	var out SetDeleteSet_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "tools.ozone.set.deleteSet", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "tools.ozone.set.deleteSet", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/setdeleteValues.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // SetDeleteValues_Input is the input argument to a tools.ozone.set.deleteValues call.
···
 }
 
 // SetDeleteValues calls the XRPC method "tools.ozone.set.deleteValues".
-func SetDeleteValues(ctx context.Context, c *xrpc.Client, input *SetDeleteValues_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "tools.ozone.set.deleteValues", nil, input, nil); err != nil {
+func SetDeleteValues(ctx context.Context, c util.LexClient, input *SetDeleteValues_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "tools.ozone.set.deleteValues", nil, input, nil); err != nil {
 		return err
 	}
 

api/ozone/setgetValues.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // SetGetValues_Output is the output of a tools.ozone.set.getValues call.
···
 }
 
 // SetGetValues calls the XRPC method "tools.ozone.set.getValues".
-func SetGetValues(ctx context.Context, c *xrpc.Client, cursor string, limit int64, name string) (*SetGetValues_Output, error) {
+func SetGetValues(ctx context.Context, c util.LexClient, cursor string, limit int64, name string) (*SetGetValues_Output, error) {
 	var out SetGetValues_Output
 
 	params := map[string]interface{}{}
···
 		params["limit"] = limit
 	}
 	params["name"] = name
-	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.set.getValues", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "tools.ozone.set.getValues", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/setquerySets.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // SetQuerySets_Output is the output of a tools.ozone.set.querySets call.
···
 // SetQuerySets calls the XRPC method "tools.ozone.set.querySets".
 //
 // sortDirection: Defaults to ascending order of name field.
-func SetQuerySets(ctx context.Context, c *xrpc.Client, cursor string, limit int64, namePrefix string, sortBy string, sortDirection string) (*SetQuerySets_Output, error) {
+func SetQuerySets(ctx context.Context, c util.LexClient, cursor string, limit int64, namePrefix string, sortBy string, sortDirection string) (*SetQuerySets_Output, error) {
 	var out SetQuerySets_Output
 
 	params := map[string]interface{}{}
···
 	if sortDirection != "" {
 		params["sortDirection"] = sortDirection
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.set.querySets", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "tools.ozone.set.querySets", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/settinglistOptions.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // SettingListOptions_Output is the output of a tools.ozone.setting.listOptions call.
···
 //
 // keys: Filter for only the specified keys. Ignored if prefix is provided
 // prefix: Filter keys by prefix
-func SettingListOptions(ctx context.Context, c *xrpc.Client, cursor string, keys []string, limit int64, prefix string, scope string) (*SettingListOptions_Output, error) {
+func SettingListOptions(ctx context.Context, c util.LexClient, cursor string, keys []string, limit int64, prefix string, scope string) (*SettingListOptions_Output, error) {
 	var out SettingListOptions_Output
 
 	params := map[string]interface{}{}
···
 	if scope != "" {
 		params["scope"] = scope
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.setting.listOptions", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "tools.ozone.setting.listOptions", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/settingremoveOptions.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // SettingRemoveOptions_Input is the input argument to a tools.ozone.setting.removeOptions call.
···
 }
 
 // SettingRemoveOptions calls the XRPC method "tools.ozone.setting.removeOptions".
-func SettingRemoveOptions(ctx context.Context, c *xrpc.Client, input *SettingRemoveOptions_Input) (*SettingRemoveOptions_Output, error) {
+func SettingRemoveOptions(ctx context.Context, c util.LexClient, input *SettingRemoveOptions_Input) (*SettingRemoveOptions_Output, error) {
 	var out SettingRemoveOptions_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "tools.ozone.setting.removeOptions", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "tools.ozone.setting.removeOptions", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/settingupsertOption.go

···
 	"context"
 
 	"github.com/bluesky-social/indigo/lex/util"
-	"github.com/bluesky-social/indigo/xrpc"
 )
 
 // SettingUpsertOption_Input is the input argument to a tools.ozone.setting.upsertOption call.
···
 }
 
 // SettingUpsertOption calls the XRPC method "tools.ozone.setting.upsertOption".
-func SettingUpsertOption(ctx context.Context, c *xrpc.Client, input *SettingUpsertOption_Input) (*SettingUpsertOption_Output, error) {
+func SettingUpsertOption(ctx context.Context, c util.LexClient, input *SettingUpsertOption_Input) (*SettingUpsertOption_Output, error) {
 	var out SettingUpsertOption_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "tools.ozone.setting.upsertOption", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "tools.ozone.setting.upsertOption", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/setupsertSet.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // SetUpsertSet calls the XRPC method "tools.ozone.set.upsertSet".
-func SetUpsertSet(ctx context.Context, c *xrpc.Client, input *SetDefs_Set) (*SetDefs_SetView, error) {
+func SetUpsertSet(ctx context.Context, c util.LexClient, input *SetDefs_Set) (*SetDefs_SetView, error) {
 	var out SetDefs_SetView
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "tools.ozone.set.upsertSet", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "tools.ozone.set.upsertSet", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/signaturefindCorrelation.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // SignatureFindCorrelation_Output is the output of a tools.ozone.signature.findCorrelation call.
···
 }
 
 // SignatureFindCorrelation calls the XRPC method "tools.ozone.signature.findCorrelation".
-func SignatureFindCorrelation(ctx context.Context, c *xrpc.Client, dids []string) (*SignatureFindCorrelation_Output, error) {
+func SignatureFindCorrelation(ctx context.Context, c util.LexClient, dids []string) (*SignatureFindCorrelation_Output, error) {
 	var out SignatureFindCorrelation_Output
 
 	params := map[string]interface{}{}
 	params["dids"] = dids
-	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.signature.findCorrelation", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "tools.ozone.signature.findCorrelation", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/signaturefindRelatedAccounts.go

···
 	"context"
 
 	comatprototypes "github.com/bluesky-social/indigo/api/atproto"
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // SignatureFindRelatedAccounts_Output is the output of a tools.ozone.signature.findRelatedAccounts call.
···
 }
 
 // SignatureFindRelatedAccounts calls the XRPC method "tools.ozone.signature.findRelatedAccounts".
-func SignatureFindRelatedAccounts(ctx context.Context, c *xrpc.Client, cursor string, did string, limit int64) (*SignatureFindRelatedAccounts_Output, error) {
+func SignatureFindRelatedAccounts(ctx context.Context, c util.LexClient, cursor string, did string, limit int64) (*SignatureFindRelatedAccounts_Output, error) {
 	var out SignatureFindRelatedAccounts_Output
 
 	params := map[string]interface{}{}
···
 	if limit != 0 {
 		params["limit"] = limit
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.signature.findRelatedAccounts", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "tools.ozone.signature.findRelatedAccounts", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/signaturesearchAccounts.go

···
 	"context"
 
 	comatprototypes "github.com/bluesky-social/indigo/api/atproto"
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // SignatureSearchAccounts_Output is the output of a tools.ozone.signature.searchAccounts call.
···
 }
 
 // SignatureSearchAccounts calls the XRPC method "tools.ozone.signature.searchAccounts".
-func SignatureSearchAccounts(ctx context.Context, c *xrpc.Client, cursor string, limit int64, values []string) (*SignatureSearchAccounts_Output, error) {
+func SignatureSearchAccounts(ctx context.Context, c util.LexClient, cursor string, limit int64, values []string) (*SignatureSearchAccounts_Output, error) {
 	var out SignatureSearchAccounts_Output
 
 	params := map[string]interface{}{}
···
 		params["limit"] = limit
 	}
 	params["values"] = values
-	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.signature.searchAccounts", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "tools.ozone.signature.searchAccounts", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/teamaddMember.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // TeamAddMember_Input is the input argument to a tools.ozone.team.addMember call.
···
 }
 
 // TeamAddMember calls the XRPC method "tools.ozone.team.addMember".
-func TeamAddMember(ctx context.Context, c *xrpc.Client, input *TeamAddMember_Input) (*TeamDefs_Member, error) {
+func TeamAddMember(ctx context.Context, c util.LexClient, input *TeamAddMember_Input) (*TeamDefs_Member, error) {
 	var out TeamDefs_Member
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "tools.ozone.team.addMember", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "tools.ozone.team.addMember", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/teamdeleteMember.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // TeamDeleteMember_Input is the input argument to a tools.ozone.team.deleteMember call.
···
 }
 
 // TeamDeleteMember calls the XRPC method "tools.ozone.team.deleteMember".
-func TeamDeleteMember(ctx context.Context, c *xrpc.Client, input *TeamDeleteMember_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "tools.ozone.team.deleteMember", nil, input, nil); err != nil {
+func TeamDeleteMember(ctx context.Context, c util.LexClient, input *TeamDeleteMember_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "tools.ozone.team.deleteMember", nil, input, nil); err != nil {
 		return err
 	}
 

api/ozone/teamlistMembers.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // TeamListMembers_Output is the output of a tools.ozone.team.listMembers call.
···
 }
 
 // TeamListMembers calls the XRPC method "tools.ozone.team.listMembers".
-func TeamListMembers(ctx context.Context, c *xrpc.Client, cursor string, disabled bool, limit int64, q string, roles []string) (*TeamListMembers_Output, error) {
+func TeamListMembers(ctx context.Context, c util.LexClient, cursor string, disabled bool, limit int64, q string, roles []string) (*TeamListMembers_Output, error) {
 	var out TeamListMembers_Output
 
 	params := map[string]interface{}{}
···
 	if len(roles) != 0 {
 		params["roles"] = roles
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.team.listMembers", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "tools.ozone.team.listMembers", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/teamupdateMember.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // TeamUpdateMember_Input is the input argument to a tools.ozone.team.updateMember call.
···
 }
 
 // TeamUpdateMember calls the XRPC method "tools.ozone.team.updateMember".
-func TeamUpdateMember(ctx context.Context, c *xrpc.Client, input *TeamUpdateMember_Input) (*TeamDefs_Member, error) {
+func TeamUpdateMember(ctx context.Context, c util.LexClient, input *TeamUpdateMember_Input) (*TeamDefs_Member, error) {
 	var out TeamDefs_Member
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "tools.ozone.team.updateMember", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "tools.ozone.team.updateMember", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/verificationgrantVerifications.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // VerificationGrantVerifications_GrantError is a "grantError" in the tools.ozone.verification.grantVerifications schema.
···
 }
 
 // VerificationGrantVerifications calls the XRPC method "tools.ozone.verification.grantVerifications".
-func VerificationGrantVerifications(ctx context.Context, c *xrpc.Client, input *VerificationGrantVerifications_Input) (*VerificationGrantVerifications_Output, error) {
+func VerificationGrantVerifications(ctx context.Context, c util.LexClient, input *VerificationGrantVerifications_Input) (*VerificationGrantVerifications_Output, error) {
 	var out VerificationGrantVerifications_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "tools.ozone.verification.grantVerifications", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "tools.ozone.verification.grantVerifications", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/verificationlistVerifications.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // VerificationListVerifications_Output is the output of a tools.ozone.verification.listVerifications call.
···
 // limit: Maximum number of results to return
 // sortDirection: Sort direction for creation date
 // subjects: Filter to specific verified DIDs
-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) {
+func VerificationListVerifications(ctx context.Context, c util.LexClient, 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{}{}
···
 	if len(subjects) != 0 {
 		params["subjects"] = subjects
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.verification.listVerifications", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "tools.ozone.verification.listVerifications", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/ozone/verificationrevokeVerifications.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // VerificationRevokeVerifications_Input is the input argument to a tools.ozone.verification.revokeVerifications call.
···
 }
 
 // VerificationRevokeVerifications calls the XRPC method "tools.ozone.verification.revokeVerifications".
-func VerificationRevokeVerifications(ctx context.Context, c *xrpc.Client, input *VerificationRevokeVerifications_Input) (*VerificationRevokeVerifications_Output, error) {
+func VerificationRevokeVerifications(ctx context.Context, c util.LexClient, input *VerificationRevokeVerifications_Input) (*VerificationRevokeVerifications_Output, error) {
 	var out VerificationRevokeVerifications_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "tools.ozone.verification.revokeVerifications", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "tools.ozone.verification.revokeVerifications", nil, input, &out); err != nil {
 		return nil, err
 	}