// Code generated by smithy-go-codegen DO NOT EDIT.

//go:build response_snapshot

package iam

import (
	"bufio"
	"bytes"
	"context"
	"errors"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/iam/types"
	smithyendpoints "github.com/aws/smithy-go/endpoints"
	"github.com/aws/smithy-go/middleware"
	"github.com/aws/smithy-go/ptr"
	smithytesting "github.com/aws/smithy-go/testing"
	smithyhttp "github.com/aws/smithy-go/transport/http"
	"io"
	"io/fs"
	"net/http"
	"net/url"
	"os"
	"strconv"
	"strings"
	"testing"
	"time"
)

const serdeRespSSPrefix = "response_snapshot"

func serdeRespSSPath(op string) string {
	return fmt.Sprintf("%s/%s.snap", serdeRespSSPrefix, op)
}

// serdeRespReadSnapshot parses a frozen wire response fixture: a status-code
// line, HTTP headers, a blank line, then the raw body.
func serdeRespReadSnapshot(op string) (int, http.Header, []byte, error) {
	raw, err := os.ReadFile(serdeRespSSPath(op))
	if err != nil {
		return 0, nil, nil, err
	}

	r := bufio.NewReader(bytes.NewReader(raw))
	statusLine, err := r.ReadString('\n')
	if err != nil {
		return 0, nil, nil, fmt.Errorf("read status line: %w", err)
	}
	status, err := strconv.Atoi(strings.TrimSpace(statusLine))
	if err != nil {
		return 0, nil, nil, fmt.Errorf("parse status: %w", err)
	}

	header := http.Header{}
	for {
		line, err := r.ReadString('\n')
		if err != nil && err != io.EOF {
			return 0, nil, nil, err
		}
		trimmed := strings.TrimRight(line, "\r\n")
		if trimmed == "" {
			break
		}
		k, v, ok := strings.Cut(trimmed, ": ")
		if !ok {
			return 0, nil, nil, fmt.Errorf("malformed header %q", trimmed)
		}
		header.Add(k, v)
		if err == io.EOF {
			break
		}
	}

	body, err := io.ReadAll(r)
	if err != nil {
		return 0, nil, nil, err
	}
	return status, header, body, nil
}

type serdeRespEndpointResolver struct{}

func (*serdeRespEndpointResolver) ResolveEndpoint(ctx context.Context, params EndpointParameters) (smithyendpoints.Endpoint, error) {
	return smithyendpoints.Endpoint{URI: url.URL{Scheme: "https", Host: "test.example.com"}}, nil
}

func serdeRespClient(status int, header http.Header, body []byte) *Client {
	return New(Options{
		Region: "us-east-1",
		HTTPClient: smithyhttp.ClientDoFunc(func(req *http.Request) (*http.Response, error) {
			resp := &http.Response{StatusCode: status, Header: header, Request: req}
			if len(body) > 0 {
				resp.ContentLength = int64(len(body))
				resp.Body = io.NopCloser(bytes.NewReader(body))
			} else {
				resp.Body = http.NoBody
			}
			return resp, nil
		}),
		EndpointResolverV2: &serdeRespEndpointResolver{},
		APIOptions: []func(*middleware.Stack) error{
			func(s *middleware.Stack) error {
				s.Finalize.Clear()
				s.Initialize.Remove("OperationInputValidation")
				return nil
			},
		},
	})
}
func TestCheckResponseSnapshot_AcceptDelegationRequest(t *testing.T) {
	want := &AcceptDelegationRequestOutput{}
	status, header, body, err := serdeRespReadSnapshot("AcceptDelegationRequest.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.AcceptDelegationRequest(context.Background(), &AcceptDelegationRequestInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "AcceptDelegationRequest.response", err)
	}
}

func TestCheckResponseSnapshot_AddClientIDToOpenIDConnectProvider(t *testing.T) {
	want := &AddClientIDToOpenIDConnectProviderOutput{}
	status, header, body, err := serdeRespReadSnapshot("AddClientIDToOpenIDConnectProvider.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.AddClientIDToOpenIDConnectProvider(context.Background(), &AddClientIDToOpenIDConnectProviderInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "AddClientIDToOpenIDConnectProvider.response", err)
	}
}

func TestCheckResponseSnapshot_AddRoleToInstanceProfile(t *testing.T) {
	want := &AddRoleToInstanceProfileOutput{}
	status, header, body, err := serdeRespReadSnapshot("AddRoleToInstanceProfile.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.AddRoleToInstanceProfile(context.Background(), &AddRoleToInstanceProfileInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "AddRoleToInstanceProfile.response", err)
	}
}

func TestCheckResponseSnapshot_AddUserToGroup(t *testing.T) {
	want := &AddUserToGroupOutput{}
	status, header, body, err := serdeRespReadSnapshot("AddUserToGroup.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.AddUserToGroup(context.Background(), &AddUserToGroupInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "AddUserToGroup.response", err)
	}
}

func TestCheckResponseSnapshot_AssociateDelegationRequest(t *testing.T) {
	want := &AssociateDelegationRequestOutput{}
	status, header, body, err := serdeRespReadSnapshot("AssociateDelegationRequest.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.AssociateDelegationRequest(context.Background(), &AssociateDelegationRequestInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "AssociateDelegationRequest.response", err)
	}
}

func TestCheckResponseSnapshot_AttachGroupPolicy(t *testing.T) {
	want := &AttachGroupPolicyOutput{}
	status, header, body, err := serdeRespReadSnapshot("AttachGroupPolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.AttachGroupPolicy(context.Background(), &AttachGroupPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "AttachGroupPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_AttachRolePolicy(t *testing.T) {
	want := &AttachRolePolicyOutput{}
	status, header, body, err := serdeRespReadSnapshot("AttachRolePolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.AttachRolePolicy(context.Background(), &AttachRolePolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "AttachRolePolicy.response", err)
	}
}

func TestCheckResponseSnapshot_AttachUserPolicy(t *testing.T) {
	want := &AttachUserPolicyOutput{}
	status, header, body, err := serdeRespReadSnapshot("AttachUserPolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.AttachUserPolicy(context.Background(), &AttachUserPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "AttachUserPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_ChangePassword(t *testing.T) {
	want := &ChangePasswordOutput{}
	status, header, body, err := serdeRespReadSnapshot("ChangePassword.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ChangePassword(context.Background(), &ChangePasswordInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ChangePassword.response", err)
	}
}

func TestCheckResponseSnapshot_CreateAccessKey(t *testing.T) {
	want := &CreateAccessKeyOutput{
		AccessKey: &types.AccessKey{
			UserName:        ptr.String("__UserName__"),
			AccessKeyId:     ptr.String("__AccessKeyId__"),
			Status:          types.StatusType("Active"),
			SecretAccessKey: ptr.String("__SecretAccessKey__"),
			CreateDate:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateAccessKey.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateAccessKey(context.Background(), &CreateAccessKeyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateAccessKey.response", err)
	}
}

func TestCheckResponseSnapshot_CreateAccountAlias(t *testing.T) {
	want := &CreateAccountAliasOutput{}
	status, header, body, err := serdeRespReadSnapshot("CreateAccountAlias.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateAccountAlias(context.Background(), &CreateAccountAliasInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateAccountAlias.response", err)
	}
}

func TestCheckResponseSnapshot_CreateDelegationRequest(t *testing.T) {
	want := &CreateDelegationRequestOutput{
		ConsoleDeepLink:     ptr.String("__ConsoleDeepLink__"),
		DelegationRequestId: ptr.String("__DelegationRequestId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CreateDelegationRequest.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateDelegationRequest(context.Background(), &CreateDelegationRequestInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateDelegationRequest.response", err)
	}
}

func TestCheckResponseSnapshot_CreateGroup(t *testing.T) {
	want := &CreateGroupOutput{
		Group: &types.Group{
			Path:       ptr.String("__Path__"),
			GroupName:  ptr.String("__GroupName__"),
			GroupId:    ptr.String("__GroupId__"),
			Arn:        ptr.String("__Arn__"),
			CreateDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateGroup.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateGroup(context.Background(), &CreateGroupInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateGroup.response", err)
	}
}

func TestCheckResponseSnapshot_CreateInstanceProfile(t *testing.T) {
	want := &CreateInstanceProfileOutput{
		InstanceProfile: &types.InstanceProfile{
			Path:                ptr.String("__Path__"),
			InstanceProfileName: ptr.String("__InstanceProfileName__"),
			InstanceProfileId:   ptr.String("__InstanceProfileId__"),
			Arn:                 ptr.String("__Arn__"),
			CreateDate:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			Roles: []types.Role{
				{
					Path:                     ptr.String("__Path__"),
					RoleName:                 ptr.String("__RoleName__"),
					RoleId:                   ptr.String("__RoleId__"),
					Arn:                      ptr.String("__Arn__"),
					CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
					Description:              ptr.String("__Description__"),
					MaxSessionDuration:       ptr.Int32(1),
					PermissionsBoundary: &types.AttachedPermissionsBoundary{
						PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
						PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
					},
					Tags: []types.Tag{
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
					},
					RoleLastUsed: &types.RoleLastUsed{
						LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Region:       ptr.String("__Region__"),
					},
				},
				{
					Path:                     ptr.String("__Path__"),
					RoleName:                 ptr.String("__RoleName__"),
					RoleId:                   ptr.String("__RoleId__"),
					Arn:                      ptr.String("__Arn__"),
					CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
					Description:              ptr.String("__Description__"),
					MaxSessionDuration:       ptr.Int32(1),
					PermissionsBoundary: &types.AttachedPermissionsBoundary{
						PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
						PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
					},
					Tags: []types.Tag{
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
					},
					RoleLastUsed: &types.RoleLastUsed{
						LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Region:       ptr.String("__Region__"),
					},
				},
			},
			Tags: []types.Tag{
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateInstanceProfile.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateInstanceProfile(context.Background(), &CreateInstanceProfileInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateInstanceProfile.response", err)
	}
}

func TestCheckResponseSnapshot_CreateLoginProfile(t *testing.T) {
	want := &CreateLoginProfileOutput{
		LoginProfile: &types.LoginProfile{
			UserName:              ptr.String("__UserName__"),
			CreateDate:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			PasswordResetRequired: true,
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateLoginProfile.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateLoginProfile(context.Background(), &CreateLoginProfileInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateLoginProfile.response", err)
	}
}

func TestCheckResponseSnapshot_CreateOpenIDConnectProvider(t *testing.T) {
	want := &CreateOpenIDConnectProviderOutput{
		OpenIDConnectProviderArn: ptr.String("__OpenIDConnectProviderArn__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateOpenIDConnectProvider.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateOpenIDConnectProvider(context.Background(), &CreateOpenIDConnectProviderInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateOpenIDConnectProvider.response", err)
	}
}

func TestCheckResponseSnapshot_CreatePolicy(t *testing.T) {
	want := &CreatePolicyOutput{
		Policy: &types.Policy{
			PolicyName:                    ptr.String("__PolicyName__"),
			PolicyId:                      ptr.String("__PolicyId__"),
			Arn:                           ptr.String("__Arn__"),
			Path:                          ptr.String("__Path__"),
			DefaultVersionId:              ptr.String("__DefaultVersionId__"),
			AttachmentCount:               ptr.Int32(1),
			PermissionsBoundaryUsageCount: ptr.Int32(1),
			IsAttachable:                  true,
			Description:                   ptr.String("__Description__"),
			CreateDate:                    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			UpdateDate:                    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			Tags: []types.Tag{
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreatePolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreatePolicy(context.Background(), &CreatePolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreatePolicy.response", err)
	}
}

func TestCheckResponseSnapshot_CreatePolicyVersion(t *testing.T) {
	want := &CreatePolicyVersionOutput{
		PolicyVersion: &types.PolicyVersion{
			Document:         ptr.String("__Document__"),
			VersionId:        ptr.String("__VersionId__"),
			IsDefaultVersion: true,
			CreateDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreatePolicyVersion.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreatePolicyVersion(context.Background(), &CreatePolicyVersionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreatePolicyVersion.response", err)
	}
}

func TestCheckResponseSnapshot_CreateRole(t *testing.T) {
	want := &CreateRoleOutput{
		Role: &types.Role{
			Path:                     ptr.String("__Path__"),
			RoleName:                 ptr.String("__RoleName__"),
			RoleId:                   ptr.String("__RoleId__"),
			Arn:                      ptr.String("__Arn__"),
			CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
			Description:              ptr.String("__Description__"),
			MaxSessionDuration:       ptr.Int32(1),
			PermissionsBoundary: &types.AttachedPermissionsBoundary{
				PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
				PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
			},
			Tags: []types.Tag{
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
			},
			RoleLastUsed: &types.RoleLastUsed{
				LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Region:       ptr.String("__Region__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateRole.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateRole(context.Background(), &CreateRoleInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateRole.response", err)
	}
}

func TestCheckResponseSnapshot_CreateSAMLProvider(t *testing.T) {
	want := &CreateSAMLProviderOutput{
		SAMLProviderArn: ptr.String("__SAMLProviderArn__"),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateSAMLProvider.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateSAMLProvider(context.Background(), &CreateSAMLProviderInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateSAMLProvider.response", err)
	}
}

func TestCheckResponseSnapshot_CreateServiceLinkedRole(t *testing.T) {
	want := &CreateServiceLinkedRoleOutput{
		Role: &types.Role{
			Path:                     ptr.String("__Path__"),
			RoleName:                 ptr.String("__RoleName__"),
			RoleId:                   ptr.String("__RoleId__"),
			Arn:                      ptr.String("__Arn__"),
			CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
			Description:              ptr.String("__Description__"),
			MaxSessionDuration:       ptr.Int32(1),
			PermissionsBoundary: &types.AttachedPermissionsBoundary{
				PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
				PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
			},
			Tags: []types.Tag{
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
			},
			RoleLastUsed: &types.RoleLastUsed{
				LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Region:       ptr.String("__Region__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateServiceLinkedRole.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateServiceLinkedRole(context.Background(), &CreateServiceLinkedRoleInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateServiceLinkedRole.response", err)
	}
}

func TestCheckResponseSnapshot_CreateServiceSpecificCredential(t *testing.T) {
	want := &CreateServiceSpecificCredentialOutput{
		ServiceSpecificCredential: &types.ServiceSpecificCredential{
			CreateDate:                  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			ExpirationDate:              ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			ServiceName:                 ptr.String("__ServiceName__"),
			ServiceUserName:             ptr.String("__ServiceUserName__"),
			ServicePassword:             ptr.String("__ServicePassword__"),
			ServiceCredentialAlias:      ptr.String("__ServiceCredentialAlias__"),
			ServiceCredentialSecret:     ptr.String("__ServiceCredentialSecret__"),
			ServiceSpecificCredentialId: ptr.String("__ServiceSpecificCredentialId__"),
			UserName:                    ptr.String("__UserName__"),
			Status:                      types.StatusType("Active"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateServiceSpecificCredential.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateServiceSpecificCredential(context.Background(), &CreateServiceSpecificCredentialInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateServiceSpecificCredential.response", err)
	}
}

func TestCheckResponseSnapshot_CreateUser(t *testing.T) {
	want := &CreateUserOutput{
		User: &types.User{
			Path:             ptr.String("__Path__"),
			UserName:         ptr.String("__UserName__"),
			UserId:           ptr.String("__UserId__"),
			Arn:              ptr.String("__Arn__"),
			CreateDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			PasswordLastUsed: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			PermissionsBoundary: &types.AttachedPermissionsBoundary{
				PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
				PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
			},
			Tags: []types.Tag{
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateUser.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateUser(context.Background(), &CreateUserInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateUser.response", err)
	}
}

func TestCheckResponseSnapshot_CreateVirtualMFADevice(t *testing.T) {
	want := &CreateVirtualMFADeviceOutput{
		VirtualMFADevice: &types.VirtualMFADevice{
			SerialNumber:     ptr.String("__SerialNumber__"),
			Base32StringSeed: []byte("blob"),
			QRCodePNG:        []byte("blob"),
			User: &types.User{
				Path:             ptr.String("__Path__"),
				UserName:         ptr.String("__UserName__"),
				UserId:           ptr.String("__UserId__"),
				Arn:              ptr.String("__Arn__"),
				CreateDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PasswordLastUsed: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PermissionsBoundary: &types.AttachedPermissionsBoundary{
					PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
					PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
				},
				Tags: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
			},
			EnableDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			Tags: []types.Tag{
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("CreateVirtualMFADevice.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.CreateVirtualMFADevice(context.Background(), &CreateVirtualMFADeviceInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "CreateVirtualMFADevice.response", err)
	}
}

func TestCheckResponseSnapshot_DeactivateMFADevice(t *testing.T) {
	want := &DeactivateMFADeviceOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeactivateMFADevice.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeactivateMFADevice(context.Background(), &DeactivateMFADeviceInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeactivateMFADevice.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteAccessKey(t *testing.T) {
	want := &DeleteAccessKeyOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteAccessKey.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteAccessKey(context.Background(), &DeleteAccessKeyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteAccessKey.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteAccountAlias(t *testing.T) {
	want := &DeleteAccountAliasOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteAccountAlias.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteAccountAlias(context.Background(), &DeleteAccountAliasInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteAccountAlias.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteAccountPasswordPolicy(t *testing.T) {
	want := &DeleteAccountPasswordPolicyOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteAccountPasswordPolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteAccountPasswordPolicy(context.Background(), &DeleteAccountPasswordPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteAccountPasswordPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteGroup(t *testing.T) {
	want := &DeleteGroupOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteGroup.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteGroup(context.Background(), &DeleteGroupInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteGroup.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteGroupPolicy(t *testing.T) {
	want := &DeleteGroupPolicyOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteGroupPolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteGroupPolicy(context.Background(), &DeleteGroupPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteGroupPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteInstanceProfile(t *testing.T) {
	want := &DeleteInstanceProfileOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteInstanceProfile.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteInstanceProfile(context.Background(), &DeleteInstanceProfileInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteInstanceProfile.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteLoginProfile(t *testing.T) {
	want := &DeleteLoginProfileOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteLoginProfile.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteLoginProfile(context.Background(), &DeleteLoginProfileInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteLoginProfile.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteOpenIDConnectProvider(t *testing.T) {
	want := &DeleteOpenIDConnectProviderOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteOpenIDConnectProvider.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteOpenIDConnectProvider(context.Background(), &DeleteOpenIDConnectProviderInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteOpenIDConnectProvider.response", err)
	}
}

func TestCheckResponseSnapshot_DeletePolicy(t *testing.T) {
	want := &DeletePolicyOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeletePolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeletePolicy(context.Background(), &DeletePolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeletePolicy.response", err)
	}
}

func TestCheckResponseSnapshot_DeletePolicyVersion(t *testing.T) {
	want := &DeletePolicyVersionOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeletePolicyVersion.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeletePolicyVersion(context.Background(), &DeletePolicyVersionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeletePolicyVersion.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteRole(t *testing.T) {
	want := &DeleteRoleOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteRole.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteRole(context.Background(), &DeleteRoleInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteRole.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteRolePermissionsBoundary(t *testing.T) {
	want := &DeleteRolePermissionsBoundaryOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteRolePermissionsBoundary.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteRolePermissionsBoundary(context.Background(), &DeleteRolePermissionsBoundaryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteRolePermissionsBoundary.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteRolePolicy(t *testing.T) {
	want := &DeleteRolePolicyOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteRolePolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteRolePolicy(context.Background(), &DeleteRolePolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteRolePolicy.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteSAMLProvider(t *testing.T) {
	want := &DeleteSAMLProviderOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteSAMLProvider.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteSAMLProvider(context.Background(), &DeleteSAMLProviderInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteSAMLProvider.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteSSHPublicKey(t *testing.T) {
	want := &DeleteSSHPublicKeyOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteSSHPublicKey.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteSSHPublicKey(context.Background(), &DeleteSSHPublicKeyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteSSHPublicKey.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteServerCertificate(t *testing.T) {
	want := &DeleteServerCertificateOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteServerCertificate.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteServerCertificate(context.Background(), &DeleteServerCertificateInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteServerCertificate.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteServiceLinkedRole(t *testing.T) {
	want := &DeleteServiceLinkedRoleOutput{
		DeletionTaskId: ptr.String("__DeletionTaskId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DeleteServiceLinkedRole.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteServiceLinkedRole(context.Background(), &DeleteServiceLinkedRoleInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteServiceLinkedRole.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteServiceSpecificCredential(t *testing.T) {
	want := &DeleteServiceSpecificCredentialOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteServiceSpecificCredential.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteServiceSpecificCredential(context.Background(), &DeleteServiceSpecificCredentialInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteServiceSpecificCredential.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteSigningCertificate(t *testing.T) {
	want := &DeleteSigningCertificateOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteSigningCertificate.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteSigningCertificate(context.Background(), &DeleteSigningCertificateInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteSigningCertificate.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteUser(t *testing.T) {
	want := &DeleteUserOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteUser.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteUser(context.Background(), &DeleteUserInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteUser.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteUserPermissionsBoundary(t *testing.T) {
	want := &DeleteUserPermissionsBoundaryOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteUserPermissionsBoundary.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteUserPermissionsBoundary(context.Background(), &DeleteUserPermissionsBoundaryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteUserPermissionsBoundary.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteUserPolicy(t *testing.T) {
	want := &DeleteUserPolicyOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteUserPolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteUserPolicy(context.Background(), &DeleteUserPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteUserPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_DeleteVirtualMFADevice(t *testing.T) {
	want := &DeleteVirtualMFADeviceOutput{}
	status, header, body, err := serdeRespReadSnapshot("DeleteVirtualMFADevice.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DeleteVirtualMFADevice(context.Background(), &DeleteVirtualMFADeviceInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DeleteVirtualMFADevice.response", err)
	}
}

func TestCheckResponseSnapshot_DetachGroupPolicy(t *testing.T) {
	want := &DetachGroupPolicyOutput{}
	status, header, body, err := serdeRespReadSnapshot("DetachGroupPolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DetachGroupPolicy(context.Background(), &DetachGroupPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DetachGroupPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_DetachRolePolicy(t *testing.T) {
	want := &DetachRolePolicyOutput{}
	status, header, body, err := serdeRespReadSnapshot("DetachRolePolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DetachRolePolicy(context.Background(), &DetachRolePolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DetachRolePolicy.response", err)
	}
}

func TestCheckResponseSnapshot_DetachUserPolicy(t *testing.T) {
	want := &DetachUserPolicyOutput{}
	status, header, body, err := serdeRespReadSnapshot("DetachUserPolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DetachUserPolicy(context.Background(), &DetachUserPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DetachUserPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_DisableOrganizationsRootCredentialsManagement(t *testing.T) {
	want := &DisableOrganizationsRootCredentialsManagementOutput{
		OrganizationId: ptr.String("__OrganizationId__"),
		EnabledFeatures: []types.FeatureType{
			types.FeatureType("RootCredentialsManagement"),
			types.FeatureType("RootCredentialsManagement"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DisableOrganizationsRootCredentialsManagement.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DisableOrganizationsRootCredentialsManagement(context.Background(), &DisableOrganizationsRootCredentialsManagementInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DisableOrganizationsRootCredentialsManagement.response", err)
	}
}

func TestCheckResponseSnapshot_DisableOrganizationsRootSessions(t *testing.T) {
	want := &DisableOrganizationsRootSessionsOutput{
		OrganizationId: ptr.String("__OrganizationId__"),
		EnabledFeatures: []types.FeatureType{
			types.FeatureType("RootCredentialsManagement"),
			types.FeatureType("RootCredentialsManagement"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("DisableOrganizationsRootSessions.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DisableOrganizationsRootSessions(context.Background(), &DisableOrganizationsRootSessionsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DisableOrganizationsRootSessions.response", err)
	}
}

func TestCheckResponseSnapshot_DisableOutboundWebIdentityFederation(t *testing.T) {
	want := &DisableOutboundWebIdentityFederationOutput{}
	status, header, body, err := serdeRespReadSnapshot("DisableOutboundWebIdentityFederation.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.DisableOutboundWebIdentityFederation(context.Background(), &DisableOutboundWebIdentityFederationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "DisableOutboundWebIdentityFederation.response", err)
	}
}

func TestCheckResponseSnapshot_EnableMFADevice(t *testing.T) {
	want := &EnableMFADeviceOutput{}
	status, header, body, err := serdeRespReadSnapshot("EnableMFADevice.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.EnableMFADevice(context.Background(), &EnableMFADeviceInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "EnableMFADevice.response", err)
	}
}

func TestCheckResponseSnapshot_EnableOrganizationsRootCredentialsManagement(t *testing.T) {
	want := &EnableOrganizationsRootCredentialsManagementOutput{
		OrganizationId: ptr.String("__OrganizationId__"),
		EnabledFeatures: []types.FeatureType{
			types.FeatureType("RootCredentialsManagement"),
			types.FeatureType("RootCredentialsManagement"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("EnableOrganizationsRootCredentialsManagement.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.EnableOrganizationsRootCredentialsManagement(context.Background(), &EnableOrganizationsRootCredentialsManagementInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "EnableOrganizationsRootCredentialsManagement.response", err)
	}
}

func TestCheckResponseSnapshot_EnableOrganizationsRootSessions(t *testing.T) {
	want := &EnableOrganizationsRootSessionsOutput{
		OrganizationId: ptr.String("__OrganizationId__"),
		EnabledFeatures: []types.FeatureType{
			types.FeatureType("RootCredentialsManagement"),
			types.FeatureType("RootCredentialsManagement"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("EnableOrganizationsRootSessions.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.EnableOrganizationsRootSessions(context.Background(), &EnableOrganizationsRootSessionsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "EnableOrganizationsRootSessions.response", err)
	}
}

func TestCheckResponseSnapshot_EnableOutboundWebIdentityFederation(t *testing.T) {
	want := &EnableOutboundWebIdentityFederationOutput{
		IssuerIdentifier: ptr.String("__IssuerIdentifier__"),
	}
	status, header, body, err := serdeRespReadSnapshot("EnableOutboundWebIdentityFederation.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.EnableOutboundWebIdentityFederation(context.Background(), &EnableOutboundWebIdentityFederationInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "EnableOutboundWebIdentityFederation.response", err)
	}
}

func TestCheckResponseSnapshot_GenerateCredentialReport(t *testing.T) {
	want := &GenerateCredentialReportOutput{
		State:       types.ReportStateType("STARTED"),
		Description: ptr.String("__Description__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GenerateCredentialReport.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GenerateCredentialReport(context.Background(), &GenerateCredentialReportInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GenerateCredentialReport.response", err)
	}
}

func TestCheckResponseSnapshot_GenerateOrganizationsAccessReport(t *testing.T) {
	want := &GenerateOrganizationsAccessReportOutput{
		JobId: ptr.String("__JobId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GenerateOrganizationsAccessReport.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GenerateOrganizationsAccessReport(context.Background(), &GenerateOrganizationsAccessReportInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GenerateOrganizationsAccessReport.response", err)
	}
}

func TestCheckResponseSnapshot_GenerateServiceLastAccessedDetails(t *testing.T) {
	want := &GenerateServiceLastAccessedDetailsOutput{
		JobId: ptr.String("__JobId__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GenerateServiceLastAccessedDetails.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GenerateServiceLastAccessedDetails(context.Background(), &GenerateServiceLastAccessedDetailsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GenerateServiceLastAccessedDetails.response", err)
	}
}

func TestCheckResponseSnapshot_GetAccessKeyLastUsed(t *testing.T) {
	want := &GetAccessKeyLastUsedOutput{
		UserName: ptr.String("__UserName__"),
		AccessKeyLastUsed: &types.AccessKeyLastUsed{
			LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			ServiceName:  ptr.String("__ServiceName__"),
			Region:       ptr.String("__Region__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetAccessKeyLastUsed.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetAccessKeyLastUsed(context.Background(), &GetAccessKeyLastUsedInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetAccessKeyLastUsed.response", err)
	}
}

func TestCheckResponseSnapshot_GetAccountAuthorizationDetails(t *testing.T) {
	want := &GetAccountAuthorizationDetailsOutput{
		UserDetailList: []types.UserDetail{
			{
				Path:       ptr.String("__Path__"),
				UserName:   ptr.String("__UserName__"),
				UserId:     ptr.String("__UserId__"),
				Arn:        ptr.String("__Arn__"),
				CreateDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UserPolicyList: []types.PolicyDetail{
					{
						PolicyName:     ptr.String("__PolicyName__"),
						PolicyDocument: ptr.String("__PolicyDocument__"),
					},
					{
						PolicyName:     ptr.String("__PolicyName__"),
						PolicyDocument: ptr.String("__PolicyDocument__"),
					},
				},
				GroupList: []string{
					"__Member__",
					"__Member__",
				},
				AttachedManagedPolicies: []types.AttachedPolicy{
					{
						PolicyName: ptr.String("__PolicyName__"),
						PolicyArn:  ptr.String("__PolicyArn__"),
					},
					{
						PolicyName: ptr.String("__PolicyName__"),
						PolicyArn:  ptr.String("__PolicyArn__"),
					},
				},
				PermissionsBoundary: &types.AttachedPermissionsBoundary{
					PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
					PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
				},
				Tags: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
			},
			{
				Path:       ptr.String("__Path__"),
				UserName:   ptr.String("__UserName__"),
				UserId:     ptr.String("__UserId__"),
				Arn:        ptr.String("__Arn__"),
				CreateDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UserPolicyList: []types.PolicyDetail{
					{
						PolicyName:     ptr.String("__PolicyName__"),
						PolicyDocument: ptr.String("__PolicyDocument__"),
					},
					{
						PolicyName:     ptr.String("__PolicyName__"),
						PolicyDocument: ptr.String("__PolicyDocument__"),
					},
				},
				GroupList: []string{
					"__Member__",
					"__Member__",
				},
				AttachedManagedPolicies: []types.AttachedPolicy{
					{
						PolicyName: ptr.String("__PolicyName__"),
						PolicyArn:  ptr.String("__PolicyArn__"),
					},
					{
						PolicyName: ptr.String("__PolicyName__"),
						PolicyArn:  ptr.String("__PolicyArn__"),
					},
				},
				PermissionsBoundary: &types.AttachedPermissionsBoundary{
					PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
					PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
				},
				Tags: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
			},
		},
		GroupDetailList: []types.GroupDetail{
			{
				Path:       ptr.String("__Path__"),
				GroupName:  ptr.String("__GroupName__"),
				GroupId:    ptr.String("__GroupId__"),
				Arn:        ptr.String("__Arn__"),
				CreateDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				GroupPolicyList: []types.PolicyDetail{
					{
						PolicyName:     ptr.String("__PolicyName__"),
						PolicyDocument: ptr.String("__PolicyDocument__"),
					},
					{
						PolicyName:     ptr.String("__PolicyName__"),
						PolicyDocument: ptr.String("__PolicyDocument__"),
					},
				},
				AttachedManagedPolicies: []types.AttachedPolicy{
					{
						PolicyName: ptr.String("__PolicyName__"),
						PolicyArn:  ptr.String("__PolicyArn__"),
					},
					{
						PolicyName: ptr.String("__PolicyName__"),
						PolicyArn:  ptr.String("__PolicyArn__"),
					},
				},
			},
			{
				Path:       ptr.String("__Path__"),
				GroupName:  ptr.String("__GroupName__"),
				GroupId:    ptr.String("__GroupId__"),
				Arn:        ptr.String("__Arn__"),
				CreateDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				GroupPolicyList: []types.PolicyDetail{
					{
						PolicyName:     ptr.String("__PolicyName__"),
						PolicyDocument: ptr.String("__PolicyDocument__"),
					},
					{
						PolicyName:     ptr.String("__PolicyName__"),
						PolicyDocument: ptr.String("__PolicyDocument__"),
					},
				},
				AttachedManagedPolicies: []types.AttachedPolicy{
					{
						PolicyName: ptr.String("__PolicyName__"),
						PolicyArn:  ptr.String("__PolicyArn__"),
					},
					{
						PolicyName: ptr.String("__PolicyName__"),
						PolicyArn:  ptr.String("__PolicyArn__"),
					},
				},
			},
		},
		RoleDetailList: []types.RoleDetail{
			{
				Path:                     ptr.String("__Path__"),
				RoleName:                 ptr.String("__RoleName__"),
				RoleId:                   ptr.String("__RoleId__"),
				Arn:                      ptr.String("__Arn__"),
				CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
				InstanceProfileList: []types.InstanceProfile{
					{
						Path:                ptr.String("__Path__"),
						InstanceProfileName: ptr.String("__InstanceProfileName__"),
						InstanceProfileId:   ptr.String("__InstanceProfileId__"),
						Arn:                 ptr.String("__Arn__"),
						CreateDate:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Roles: []types.Role{
							{
								Path:                     ptr.String("__Path__"),
								RoleName:                 ptr.String("__RoleName__"),
								RoleId:                   ptr.String("__RoleId__"),
								Arn:                      ptr.String("__Arn__"),
								CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
								AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
								Description:              ptr.String("__Description__"),
								MaxSessionDuration:       ptr.Int32(1),
								PermissionsBoundary: &types.AttachedPermissionsBoundary{
									PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
									PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
								},
								Tags: []types.Tag{
									{
										Key:   ptr.String("__Key__"),
										Value: ptr.String("__Value__"),
									},
									{
										Key:   ptr.String("__Key__"),
										Value: ptr.String("__Value__"),
									},
								},
								RoleLastUsed: &types.RoleLastUsed{
									LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
									Region:       ptr.String("__Region__"),
								},
							},
							{
								Path:                     ptr.String("__Path__"),
								RoleName:                 ptr.String("__RoleName__"),
								RoleId:                   ptr.String("__RoleId__"),
								Arn:                      ptr.String("__Arn__"),
								CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
								AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
								Description:              ptr.String("__Description__"),
								MaxSessionDuration:       ptr.Int32(1),
								PermissionsBoundary: &types.AttachedPermissionsBoundary{
									PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
									PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
								},
								Tags: []types.Tag{
									{
										Key:   ptr.String("__Key__"),
										Value: ptr.String("__Value__"),
									},
									{
										Key:   ptr.String("__Key__"),
										Value: ptr.String("__Value__"),
									},
								},
								RoleLastUsed: &types.RoleLastUsed{
									LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
									Region:       ptr.String("__Region__"),
								},
							},
						},
						Tags: []types.Tag{
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
						},
					},
					{
						Path:                ptr.String("__Path__"),
						InstanceProfileName: ptr.String("__InstanceProfileName__"),
						InstanceProfileId:   ptr.String("__InstanceProfileId__"),
						Arn:                 ptr.String("__Arn__"),
						CreateDate:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Roles: []types.Role{
							{
								Path:                     ptr.String("__Path__"),
								RoleName:                 ptr.String("__RoleName__"),
								RoleId:                   ptr.String("__RoleId__"),
								Arn:                      ptr.String("__Arn__"),
								CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
								AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
								Description:              ptr.String("__Description__"),
								MaxSessionDuration:       ptr.Int32(1),
								PermissionsBoundary: &types.AttachedPermissionsBoundary{
									PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
									PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
								},
								Tags: []types.Tag{
									{
										Key:   ptr.String("__Key__"),
										Value: ptr.String("__Value__"),
									},
									{
										Key:   ptr.String("__Key__"),
										Value: ptr.String("__Value__"),
									},
								},
								RoleLastUsed: &types.RoleLastUsed{
									LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
									Region:       ptr.String("__Region__"),
								},
							},
							{
								Path:                     ptr.String("__Path__"),
								RoleName:                 ptr.String("__RoleName__"),
								RoleId:                   ptr.String("__RoleId__"),
								Arn:                      ptr.String("__Arn__"),
								CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
								AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
								Description:              ptr.String("__Description__"),
								MaxSessionDuration:       ptr.Int32(1),
								PermissionsBoundary: &types.AttachedPermissionsBoundary{
									PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
									PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
								},
								Tags: []types.Tag{
									{
										Key:   ptr.String("__Key__"),
										Value: ptr.String("__Value__"),
									},
									{
										Key:   ptr.String("__Key__"),
										Value: ptr.String("__Value__"),
									},
								},
								RoleLastUsed: &types.RoleLastUsed{
									LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
									Region:       ptr.String("__Region__"),
								},
							},
						},
						Tags: []types.Tag{
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
						},
					},
				},
				RolePolicyList: []types.PolicyDetail{
					{
						PolicyName:     ptr.String("__PolicyName__"),
						PolicyDocument: ptr.String("__PolicyDocument__"),
					},
					{
						PolicyName:     ptr.String("__PolicyName__"),
						PolicyDocument: ptr.String("__PolicyDocument__"),
					},
				},
				AttachedManagedPolicies: []types.AttachedPolicy{
					{
						PolicyName: ptr.String("__PolicyName__"),
						PolicyArn:  ptr.String("__PolicyArn__"),
					},
					{
						PolicyName: ptr.String("__PolicyName__"),
						PolicyArn:  ptr.String("__PolicyArn__"),
					},
				},
				PermissionsBoundary: &types.AttachedPermissionsBoundary{
					PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
					PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
				},
				Tags: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
				RoleLastUsed: &types.RoleLastUsed{
					LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					Region:       ptr.String("__Region__"),
				},
			},
			{
				Path:                     ptr.String("__Path__"),
				RoleName:                 ptr.String("__RoleName__"),
				RoleId:                   ptr.String("__RoleId__"),
				Arn:                      ptr.String("__Arn__"),
				CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
				InstanceProfileList: []types.InstanceProfile{
					{
						Path:                ptr.String("__Path__"),
						InstanceProfileName: ptr.String("__InstanceProfileName__"),
						InstanceProfileId:   ptr.String("__InstanceProfileId__"),
						Arn:                 ptr.String("__Arn__"),
						CreateDate:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Roles: []types.Role{
							{
								Path:                     ptr.String("__Path__"),
								RoleName:                 ptr.String("__RoleName__"),
								RoleId:                   ptr.String("__RoleId__"),
								Arn:                      ptr.String("__Arn__"),
								CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
								AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
								Description:              ptr.String("__Description__"),
								MaxSessionDuration:       ptr.Int32(1),
								PermissionsBoundary: &types.AttachedPermissionsBoundary{
									PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
									PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
								},
								Tags: []types.Tag{
									{
										Key:   ptr.String("__Key__"),
										Value: ptr.String("__Value__"),
									},
									{
										Key:   ptr.String("__Key__"),
										Value: ptr.String("__Value__"),
									},
								},
								RoleLastUsed: &types.RoleLastUsed{
									LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
									Region:       ptr.String("__Region__"),
								},
							},
							{
								Path:                     ptr.String("__Path__"),
								RoleName:                 ptr.String("__RoleName__"),
								RoleId:                   ptr.String("__RoleId__"),
								Arn:                      ptr.String("__Arn__"),
								CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
								AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
								Description:              ptr.String("__Description__"),
								MaxSessionDuration:       ptr.Int32(1),
								PermissionsBoundary: &types.AttachedPermissionsBoundary{
									PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
									PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
								},
								Tags: []types.Tag{
									{
										Key:   ptr.String("__Key__"),
										Value: ptr.String("__Value__"),
									},
									{
										Key:   ptr.String("__Key__"),
										Value: ptr.String("__Value__"),
									},
								},
								RoleLastUsed: &types.RoleLastUsed{
									LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
									Region:       ptr.String("__Region__"),
								},
							},
						},
						Tags: []types.Tag{
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
						},
					},
					{
						Path:                ptr.String("__Path__"),
						InstanceProfileName: ptr.String("__InstanceProfileName__"),
						InstanceProfileId:   ptr.String("__InstanceProfileId__"),
						Arn:                 ptr.String("__Arn__"),
						CreateDate:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Roles: []types.Role{
							{
								Path:                     ptr.String("__Path__"),
								RoleName:                 ptr.String("__RoleName__"),
								RoleId:                   ptr.String("__RoleId__"),
								Arn:                      ptr.String("__Arn__"),
								CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
								AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
								Description:              ptr.String("__Description__"),
								MaxSessionDuration:       ptr.Int32(1),
								PermissionsBoundary: &types.AttachedPermissionsBoundary{
									PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
									PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
								},
								Tags: []types.Tag{
									{
										Key:   ptr.String("__Key__"),
										Value: ptr.String("__Value__"),
									},
									{
										Key:   ptr.String("__Key__"),
										Value: ptr.String("__Value__"),
									},
								},
								RoleLastUsed: &types.RoleLastUsed{
									LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
									Region:       ptr.String("__Region__"),
								},
							},
							{
								Path:                     ptr.String("__Path__"),
								RoleName:                 ptr.String("__RoleName__"),
								RoleId:                   ptr.String("__RoleId__"),
								Arn:                      ptr.String("__Arn__"),
								CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
								AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
								Description:              ptr.String("__Description__"),
								MaxSessionDuration:       ptr.Int32(1),
								PermissionsBoundary: &types.AttachedPermissionsBoundary{
									PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
									PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
								},
								Tags: []types.Tag{
									{
										Key:   ptr.String("__Key__"),
										Value: ptr.String("__Value__"),
									},
									{
										Key:   ptr.String("__Key__"),
										Value: ptr.String("__Value__"),
									},
								},
								RoleLastUsed: &types.RoleLastUsed{
									LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
									Region:       ptr.String("__Region__"),
								},
							},
						},
						Tags: []types.Tag{
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
						},
					},
				},
				RolePolicyList: []types.PolicyDetail{
					{
						PolicyName:     ptr.String("__PolicyName__"),
						PolicyDocument: ptr.String("__PolicyDocument__"),
					},
					{
						PolicyName:     ptr.String("__PolicyName__"),
						PolicyDocument: ptr.String("__PolicyDocument__"),
					},
				},
				AttachedManagedPolicies: []types.AttachedPolicy{
					{
						PolicyName: ptr.String("__PolicyName__"),
						PolicyArn:  ptr.String("__PolicyArn__"),
					},
					{
						PolicyName: ptr.String("__PolicyName__"),
						PolicyArn:  ptr.String("__PolicyArn__"),
					},
				},
				PermissionsBoundary: &types.AttachedPermissionsBoundary{
					PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
					PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
				},
				Tags: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
				RoleLastUsed: &types.RoleLastUsed{
					LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					Region:       ptr.String("__Region__"),
				},
			},
		},
		Policies: []types.ManagedPolicyDetail{
			{
				PolicyName:                    ptr.String("__PolicyName__"),
				PolicyId:                      ptr.String("__PolicyId__"),
				Arn:                           ptr.String("__Arn__"),
				Path:                          ptr.String("__Path__"),
				DefaultVersionId:              ptr.String("__DefaultVersionId__"),
				AttachmentCount:               ptr.Int32(1),
				PermissionsBoundaryUsageCount: ptr.Int32(1),
				IsAttachable:                  true,
				Description:                   ptr.String("__Description__"),
				CreateDate:                    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdateDate:                    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PolicyVersionList: []types.PolicyVersion{
					{
						Document:         ptr.String("__Document__"),
						VersionId:        ptr.String("__VersionId__"),
						IsDefaultVersion: true,
						CreateDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
					{
						Document:         ptr.String("__Document__"),
						VersionId:        ptr.String("__VersionId__"),
						IsDefaultVersion: true,
						CreateDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
				},
			},
			{
				PolicyName:                    ptr.String("__PolicyName__"),
				PolicyId:                      ptr.String("__PolicyId__"),
				Arn:                           ptr.String("__Arn__"),
				Path:                          ptr.String("__Path__"),
				DefaultVersionId:              ptr.String("__DefaultVersionId__"),
				AttachmentCount:               ptr.Int32(1),
				PermissionsBoundaryUsageCount: ptr.Int32(1),
				IsAttachable:                  true,
				Description:                   ptr.String("__Description__"),
				CreateDate:                    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdateDate:                    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PolicyVersionList: []types.PolicyVersion{
					{
						Document:         ptr.String("__Document__"),
						VersionId:        ptr.String("__VersionId__"),
						IsDefaultVersion: true,
						CreateDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
					{
						Document:         ptr.String("__Document__"),
						VersionId:        ptr.String("__VersionId__"),
						IsDefaultVersion: true,
						CreateDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					},
				},
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetAccountAuthorizationDetails.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetAccountAuthorizationDetails(context.Background(), &GetAccountAuthorizationDetailsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetAccountAuthorizationDetails.response", err)
	}
}

func TestCheckResponseSnapshot_GetAccountPasswordPolicy(t *testing.T) {
	want := &GetAccountPasswordPolicyOutput{
		PasswordPolicy: &types.PasswordPolicy{
			MinimumPasswordLength:      ptr.Int32(1),
			RequireSymbols:             true,
			RequireNumbers:             true,
			RequireUppercaseCharacters: true,
			RequireLowercaseCharacters: true,
			AllowUsersToChangePassword: true,
			ExpirePasswords:            true,
			MaxPasswordAge:             ptr.Int32(1),
			PasswordReusePrevention:    ptr.Int32(1),
			HardExpiry:                 ptr.Bool(true),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetAccountPasswordPolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetAccountPasswordPolicy(context.Background(), &GetAccountPasswordPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetAccountPasswordPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_GetAccountSummary(t *testing.T) {
	want := &GetAccountSummaryOutput{
		SummaryMap: map[string]int32{
			"key0": 1,
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetAccountSummary.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetAccountSummary(context.Background(), &GetAccountSummaryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetAccountSummary.response", err)
	}
}

func TestCheckResponseSnapshot_GetContextKeysForCustomPolicy(t *testing.T) {
	want := &GetContextKeysForCustomPolicyOutput{
		ContextKeyNames: []string{
			"__Member__",
			"__Member__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetContextKeysForCustomPolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetContextKeysForCustomPolicy(context.Background(), &GetContextKeysForCustomPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetContextKeysForCustomPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_GetContextKeysForPrincipalPolicy(t *testing.T) {
	want := &GetContextKeysForPrincipalPolicyOutput{
		ContextKeyNames: []string{
			"__Member__",
			"__Member__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetContextKeysForPrincipalPolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetContextKeysForPrincipalPolicy(context.Background(), &GetContextKeysForPrincipalPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetContextKeysForPrincipalPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_GetCredentialReport(t *testing.T) {
	want := &GetCredentialReportOutput{
		Content:       []byte("blob"),
		ReportFormat:  types.ReportFormatType("text/csv"),
		GeneratedTime: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
	}
	status, header, body, err := serdeRespReadSnapshot("GetCredentialReport.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetCredentialReport(context.Background(), &GetCredentialReportInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetCredentialReport.response", err)
	}
}

func TestCheckResponseSnapshot_GetDelegationRequest(t *testing.T) {
	want := &GetDelegationRequestOutput{
		DelegationRequest: &types.DelegationRequest{
			DelegationRequestId: ptr.String("__DelegationRequestId__"),
			OwnerAccountId:      ptr.String("__OwnerAccountId__"),
			Description:         ptr.String("__Description__"),
			RequestMessage:      ptr.String("__RequestMessage__"),
			Permissions: &types.DelegationPermission{
				PolicyTemplateArn: ptr.String("__PolicyTemplateArn__"),
				Parameters: []types.PolicyParameter{
					{
						Name: ptr.String("__Name__"),
						Values: []string{
							"__Member__",
							"__Member__",
						},
						Type: types.PolicyParameterTypeEnum("string"),
					},
					{
						Name: ptr.String("__Name__"),
						Values: []string{
							"__Member__",
							"__Member__",
						},
						Type: types.PolicyParameterTypeEnum("string"),
					},
				},
			},
			PermissionPolicy: ptr.String("__PermissionPolicy__"),
			RolePermissionRestrictionArns: []string{
				"__Member__",
				"__Member__",
			},
			OwnerId:         ptr.String("__OwnerId__"),
			ApproverId:      ptr.String("__ApproverId__"),
			State:           types.StateType("UNASSIGNED"),
			ExpirationTime:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			RequestorId:     ptr.String("__RequestorId__"),
			RequestorName:   ptr.String("__RequestorName__"),
			CreateDate:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			SessionDuration: ptr.Int32(1),
			RedirectUrl:     ptr.String("__RedirectUrl__"),
			Notes:           ptr.String("__Notes__"),
			RejectionReason: ptr.String("__RejectionReason__"),
			OnlySendByOwner: true,
			UpdatedTime:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		PermissionCheckStatus: types.PermissionCheckStatusType("COMPLETE"),
		PermissionCheckResult: types.PermissionCheckResultType("ALLOWED"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetDelegationRequest.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetDelegationRequest(context.Background(), &GetDelegationRequestInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetDelegationRequest.response", err)
	}
}

func TestCheckResponseSnapshot_GetGroup(t *testing.T) {
	want := &GetGroupOutput{
		Group: &types.Group{
			Path:       ptr.String("__Path__"),
			GroupName:  ptr.String("__GroupName__"),
			GroupId:    ptr.String("__GroupId__"),
			Arn:        ptr.String("__Arn__"),
			CreateDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		Users: []types.User{
			{
				Path:             ptr.String("__Path__"),
				UserName:         ptr.String("__UserName__"),
				UserId:           ptr.String("__UserId__"),
				Arn:              ptr.String("__Arn__"),
				CreateDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PasswordLastUsed: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PermissionsBoundary: &types.AttachedPermissionsBoundary{
					PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
					PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
				},
				Tags: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
			},
			{
				Path:             ptr.String("__Path__"),
				UserName:         ptr.String("__UserName__"),
				UserId:           ptr.String("__UserId__"),
				Arn:              ptr.String("__Arn__"),
				CreateDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PasswordLastUsed: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PermissionsBoundary: &types.AttachedPermissionsBoundary{
					PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
					PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
				},
				Tags: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetGroup.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetGroup(context.Background(), &GetGroupInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetGroup.response", err)
	}
}

func TestCheckResponseSnapshot_GetGroupPolicy(t *testing.T) {
	want := &GetGroupPolicyOutput{
		GroupName:      ptr.String("__GroupName__"),
		PolicyName:     ptr.String("__PolicyName__"),
		PolicyDocument: ptr.String("__PolicyDocument__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetGroupPolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetGroupPolicy(context.Background(), &GetGroupPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetGroupPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_GetHumanReadableSummary(t *testing.T) {
	want := &GetHumanReadableSummaryOutput{
		SummaryContent: ptr.String("__SummaryContent__"),
		Locale:         ptr.String("__Locale__"),
		SummaryState:   types.SummaryStateType("AVAILABLE"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetHumanReadableSummary.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetHumanReadableSummary(context.Background(), &GetHumanReadableSummaryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetHumanReadableSummary.response", err)
	}
}

func TestCheckResponseSnapshot_GetInstanceProfile(t *testing.T) {
	want := &GetInstanceProfileOutput{
		InstanceProfile: &types.InstanceProfile{
			Path:                ptr.String("__Path__"),
			InstanceProfileName: ptr.String("__InstanceProfileName__"),
			InstanceProfileId:   ptr.String("__InstanceProfileId__"),
			Arn:                 ptr.String("__Arn__"),
			CreateDate:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			Roles: []types.Role{
				{
					Path:                     ptr.String("__Path__"),
					RoleName:                 ptr.String("__RoleName__"),
					RoleId:                   ptr.String("__RoleId__"),
					Arn:                      ptr.String("__Arn__"),
					CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
					Description:              ptr.String("__Description__"),
					MaxSessionDuration:       ptr.Int32(1),
					PermissionsBoundary: &types.AttachedPermissionsBoundary{
						PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
						PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
					},
					Tags: []types.Tag{
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
					},
					RoleLastUsed: &types.RoleLastUsed{
						LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Region:       ptr.String("__Region__"),
					},
				},
				{
					Path:                     ptr.String("__Path__"),
					RoleName:                 ptr.String("__RoleName__"),
					RoleId:                   ptr.String("__RoleId__"),
					Arn:                      ptr.String("__Arn__"),
					CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
					Description:              ptr.String("__Description__"),
					MaxSessionDuration:       ptr.Int32(1),
					PermissionsBoundary: &types.AttachedPermissionsBoundary{
						PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
						PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
					},
					Tags: []types.Tag{
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
					},
					RoleLastUsed: &types.RoleLastUsed{
						LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						Region:       ptr.String("__Region__"),
					},
				},
			},
			Tags: []types.Tag{
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetInstanceProfile.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetInstanceProfile(context.Background(), &GetInstanceProfileInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetInstanceProfile.response", err)
	}
}

func TestCheckResponseSnapshot_GetLoginProfile(t *testing.T) {
	want := &GetLoginProfileOutput{
		LoginProfile: &types.LoginProfile{
			UserName:              ptr.String("__UserName__"),
			CreateDate:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			PasswordResetRequired: true,
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetLoginProfile.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetLoginProfile(context.Background(), &GetLoginProfileInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetLoginProfile.response", err)
	}
}

func TestCheckResponseSnapshot_GetMFADevice(t *testing.T) {
	want := &GetMFADeviceOutput{
		UserName:     ptr.String("__UserName__"),
		SerialNumber: ptr.String("__SerialNumber__"),
		EnableDate:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		Certifications: map[string]string{
			"key0": "__Value__",
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetMFADevice.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetMFADevice(context.Background(), &GetMFADeviceInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetMFADevice.response", err)
	}
}

func TestCheckResponseSnapshot_GetOpenIDConnectProvider(t *testing.T) {
	want := &GetOpenIDConnectProviderOutput{
		Url: ptr.String("__Url__"),
		ClientIDList: []string{
			"__Member__",
			"__Member__",
		},
		ThumbprintList: []string{
			"__Member__",
			"__Member__",
		},
		CreateDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetOpenIDConnectProvider.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetOpenIDConnectProvider(context.Background(), &GetOpenIDConnectProviderInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetOpenIDConnectProvider.response", err)
	}
}

func TestCheckResponseSnapshot_GetOrganizationsAccessReport(t *testing.T) {
	want := &GetOrganizationsAccessReportOutput{
		JobStatus:                   types.JobStatusType("IN_PROGRESS"),
		JobCreationDate:             ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		JobCompletionDate:           ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		NumberOfServicesAccessible:  ptr.Int32(1),
		NumberOfServicesNotAccessed: ptr.Int32(1),
		AccessDetails: []types.AccessDetail{
			{
				ServiceName:                ptr.String("__ServiceName__"),
				ServiceNamespace:           ptr.String("__ServiceNamespace__"),
				Region:                     ptr.String("__Region__"),
				EntityPath:                 ptr.String("__EntityPath__"),
				LastAuthenticatedTime:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				TotalAuthenticatedEntities: ptr.Int32(1),
			},
			{
				ServiceName:                ptr.String("__ServiceName__"),
				ServiceNamespace:           ptr.String("__ServiceNamespace__"),
				Region:                     ptr.String("__Region__"),
				EntityPath:                 ptr.String("__EntityPath__"),
				LastAuthenticatedTime:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				TotalAuthenticatedEntities: ptr.Int32(1),
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
		ErrorDetails: &types.ErrorDetails{
			Message: ptr.String("__Message__"),
			Code:    ptr.String("__Code__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetOrganizationsAccessReport.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetOrganizationsAccessReport(context.Background(), &GetOrganizationsAccessReportInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetOrganizationsAccessReport.response", err)
	}
}

func TestCheckResponseSnapshot_GetOutboundWebIdentityFederationInfo(t *testing.T) {
	want := &GetOutboundWebIdentityFederationInfoOutput{
		IssuerIdentifier:  ptr.String("__IssuerIdentifier__"),
		JwtVendingEnabled: true,
	}
	status, header, body, err := serdeRespReadSnapshot("GetOutboundWebIdentityFederationInfo.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetOutboundWebIdentityFederationInfo(context.Background(), &GetOutboundWebIdentityFederationInfoInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetOutboundWebIdentityFederationInfo.response", err)
	}
}

func TestCheckResponseSnapshot_GetPolicy(t *testing.T) {
	want := &GetPolicyOutput{
		Policy: &types.Policy{
			PolicyName:                    ptr.String("__PolicyName__"),
			PolicyId:                      ptr.String("__PolicyId__"),
			Arn:                           ptr.String("__Arn__"),
			Path:                          ptr.String("__Path__"),
			DefaultVersionId:              ptr.String("__DefaultVersionId__"),
			AttachmentCount:               ptr.Int32(1),
			PermissionsBoundaryUsageCount: ptr.Int32(1),
			IsAttachable:                  true,
			Description:                   ptr.String("__Description__"),
			CreateDate:                    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			UpdateDate:                    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			Tags: []types.Tag{
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetPolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetPolicy(context.Background(), &GetPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_GetPolicyVersion(t *testing.T) {
	want := &GetPolicyVersionOutput{
		PolicyVersion: &types.PolicyVersion{
			Document:         ptr.String("__Document__"),
			VersionId:        ptr.String("__VersionId__"),
			IsDefaultVersion: true,
			CreateDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetPolicyVersion.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetPolicyVersion(context.Background(), &GetPolicyVersionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetPolicyVersion.response", err)
	}
}

func TestCheckResponseSnapshot_GetRole(t *testing.T) {
	want := &GetRoleOutput{
		Role: &types.Role{
			Path:                     ptr.String("__Path__"),
			RoleName:                 ptr.String("__RoleName__"),
			RoleId:                   ptr.String("__RoleId__"),
			Arn:                      ptr.String("__Arn__"),
			CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
			Description:              ptr.String("__Description__"),
			MaxSessionDuration:       ptr.Int32(1),
			PermissionsBoundary: &types.AttachedPermissionsBoundary{
				PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
				PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
			},
			Tags: []types.Tag{
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
			},
			RoleLastUsed: &types.RoleLastUsed{
				LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Region:       ptr.String("__Region__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetRole.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetRole(context.Background(), &GetRoleInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetRole.response", err)
	}
}

func TestCheckResponseSnapshot_GetRolePolicy(t *testing.T) {
	want := &GetRolePolicyOutput{
		RoleName:       ptr.String("__RoleName__"),
		PolicyName:     ptr.String("__PolicyName__"),
		PolicyDocument: ptr.String("__PolicyDocument__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetRolePolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetRolePolicy(context.Background(), &GetRolePolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetRolePolicy.response", err)
	}
}

func TestCheckResponseSnapshot_GetSAMLProvider(t *testing.T) {
	want := &GetSAMLProviderOutput{
		SAMLProviderUUID:     ptr.String("__SAMLProviderUUID__"),
		SAMLMetadataDocument: ptr.String("__SAMLMetadataDocument__"),
		CreateDate:           ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ValidUntil:           ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		AssertionEncryptionMode: types.AssertionEncryptionModeType("Required"),
		PrivateKeyList: []types.SAMLPrivateKey{
			{
				KeyId:     ptr.String("__KeyId__"),
				Timestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				KeyId:     ptr.String("__KeyId__"),
				Timestamp: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetSAMLProvider.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetSAMLProvider(context.Background(), &GetSAMLProviderInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetSAMLProvider.response", err)
	}
}

func TestCheckResponseSnapshot_GetSSHPublicKey(t *testing.T) {
	want := &GetSSHPublicKeyOutput{
		SSHPublicKey: &types.SSHPublicKey{
			UserName:         ptr.String("__UserName__"),
			SSHPublicKeyId:   ptr.String("__SSHPublicKeyId__"),
			Fingerprint:      ptr.String("__Fingerprint__"),
			SSHPublicKeyBody: ptr.String("__SSHPublicKeyBody__"),
			Status:           types.StatusType("Active"),
			UploadDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetSSHPublicKey.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetSSHPublicKey(context.Background(), &GetSSHPublicKeyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetSSHPublicKey.response", err)
	}
}

func TestCheckResponseSnapshot_GetServerCertificate(t *testing.T) {
	want := &GetServerCertificateOutput{
		ServerCertificate: &types.ServerCertificate{
			ServerCertificateMetadata: &types.ServerCertificateMetadata{
				Path:                  ptr.String("__Path__"),
				ServerCertificateName: ptr.String("__ServerCertificateName__"),
				ServerCertificateId:   ptr.String("__ServerCertificateId__"),
				Arn:                   ptr.String("__Arn__"),
				UploadDate:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Expiration:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			CertificateBody:  ptr.String("__CertificateBody__"),
			CertificateChain: ptr.String("__CertificateChain__"),
			Tags: []types.Tag{
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetServerCertificate.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetServerCertificate(context.Background(), &GetServerCertificateInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetServerCertificate.response", err)
	}
}

func TestCheckResponseSnapshot_GetServiceLastAccessedDetails(t *testing.T) {
	want := &GetServiceLastAccessedDetailsOutput{
		JobStatus:       types.JobStatusType("IN_PROGRESS"),
		JobType:         types.AccessAdvisorUsageGranularityType("SERVICE_LEVEL"),
		JobCreationDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		ServicesLastAccessed: []types.ServiceLastAccessed{
			{
				ServiceName:                ptr.String("__ServiceName__"),
				LastAuthenticated:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ServiceNamespace:           ptr.String("__ServiceNamespace__"),
				LastAuthenticatedEntity:    ptr.String("__LastAuthenticatedEntity__"),
				LastAuthenticatedRegion:    ptr.String("__LastAuthenticatedRegion__"),
				TotalAuthenticatedEntities: ptr.Int32(1),
				TrackedActionsLastAccessed: []types.TrackedActionLastAccessed{
					{
						ActionName:         ptr.String("__ActionName__"),
						LastAccessedEntity: ptr.String("__LastAccessedEntity__"),
						LastAccessedTime:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						LastAccessedRegion: ptr.String("__LastAccessedRegion__"),
					},
					{
						ActionName:         ptr.String("__ActionName__"),
						LastAccessedEntity: ptr.String("__LastAccessedEntity__"),
						LastAccessedTime:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						LastAccessedRegion: ptr.String("__LastAccessedRegion__"),
					},
				},
			},
			{
				ServiceName:                ptr.String("__ServiceName__"),
				LastAuthenticated:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ServiceNamespace:           ptr.String("__ServiceNamespace__"),
				LastAuthenticatedEntity:    ptr.String("__LastAuthenticatedEntity__"),
				LastAuthenticatedRegion:    ptr.String("__LastAuthenticatedRegion__"),
				TotalAuthenticatedEntities: ptr.Int32(1),
				TrackedActionsLastAccessed: []types.TrackedActionLastAccessed{
					{
						ActionName:         ptr.String("__ActionName__"),
						LastAccessedEntity: ptr.String("__LastAccessedEntity__"),
						LastAccessedTime:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						LastAccessedRegion: ptr.String("__LastAccessedRegion__"),
					},
					{
						ActionName:         ptr.String("__ActionName__"),
						LastAccessedEntity: ptr.String("__LastAccessedEntity__"),
						LastAccessedTime:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						LastAccessedRegion: ptr.String("__LastAccessedRegion__"),
					},
				},
			},
		},
		JobCompletionDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		IsTruncated:       true,
		Marker:            ptr.String("__Marker__"),
		Error: &types.ErrorDetails{
			Message: ptr.String("__Message__"),
			Code:    ptr.String("__Code__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetServiceLastAccessedDetails.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetServiceLastAccessedDetails(context.Background(), &GetServiceLastAccessedDetailsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetServiceLastAccessedDetails.response", err)
	}
}

func TestCheckResponseSnapshot_GetServiceLastAccessedDetailsWithEntities(t *testing.T) {
	want := &GetServiceLastAccessedDetailsWithEntitiesOutput{
		JobStatus:         types.JobStatusType("IN_PROGRESS"),
		JobCreationDate:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		JobCompletionDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		EntityDetailsList: []types.EntityDetails{
			{
				EntityInfo: &types.EntityInfo{
					Arn:  ptr.String("__Arn__"),
					Name: ptr.String("__Name__"),
					Type: types.PolicyOwnerEntityType("USER"),
					Id:   ptr.String("__Id__"),
					Path: ptr.String("__Path__"),
				},
				LastAuthenticated: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				EntityInfo: &types.EntityInfo{
					Arn:  ptr.String("__Arn__"),
					Name: ptr.String("__Name__"),
					Type: types.PolicyOwnerEntityType("USER"),
					Id:   ptr.String("__Id__"),
					Path: ptr.String("__Path__"),
				},
				LastAuthenticated: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
		Error: &types.ErrorDetails{
			Message: ptr.String("__Message__"),
			Code:    ptr.String("__Code__"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetServiceLastAccessedDetailsWithEntities.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetServiceLastAccessedDetailsWithEntities(context.Background(), &GetServiceLastAccessedDetailsWithEntitiesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetServiceLastAccessedDetailsWithEntities.response", err)
	}
}

func TestCheckResponseSnapshot_GetServiceLinkedRoleDeletionStatus(t *testing.T) {
	want := &GetServiceLinkedRoleDeletionStatusOutput{
		Status: types.DeletionTaskStatusType("SUCCEEDED"),
		Reason: &types.DeletionTaskFailureReasonType{
			Reason: ptr.String("__Reason__"),
			RoleUsageList: []types.RoleUsageType{
				{
					Region: ptr.String("__Region__"),
					Resources: []string{
						"__Member__",
						"__Member__",
					},
				},
				{
					Region: ptr.String("__Region__"),
					Resources: []string{
						"__Member__",
						"__Member__",
					},
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetServiceLinkedRoleDeletionStatus.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetServiceLinkedRoleDeletionStatus(context.Background(), &GetServiceLinkedRoleDeletionStatusInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetServiceLinkedRoleDeletionStatus.response", err)
	}
}

func TestCheckResponseSnapshot_GetUser(t *testing.T) {
	want := &GetUserOutput{
		User: &types.User{
			Path:             ptr.String("__Path__"),
			UserName:         ptr.String("__UserName__"),
			UserId:           ptr.String("__UserId__"),
			Arn:              ptr.String("__Arn__"),
			CreateDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			PasswordLastUsed: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			PermissionsBoundary: &types.AttachedPermissionsBoundary{
				PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
				PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
			},
			Tags: []types.Tag{
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("GetUser.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetUser(context.Background(), &GetUserInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetUser.response", err)
	}
}

func TestCheckResponseSnapshot_GetUserPolicy(t *testing.T) {
	want := &GetUserPolicyOutput{
		UserName:       ptr.String("__UserName__"),
		PolicyName:     ptr.String("__PolicyName__"),
		PolicyDocument: ptr.String("__PolicyDocument__"),
	}
	status, header, body, err := serdeRespReadSnapshot("GetUserPolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.GetUserPolicy(context.Background(), &GetUserPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "GetUserPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_ListAccessKeys(t *testing.T) {
	want := &ListAccessKeysOutput{
		AccessKeyMetadata: []types.AccessKeyMetadata{
			{
				UserName:    ptr.String("__UserName__"),
				AccessKeyId: ptr.String("__AccessKeyId__"),
				Status:      types.StatusType("Active"),
				CreateDate:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				UserName:    ptr.String("__UserName__"),
				AccessKeyId: ptr.String("__AccessKeyId__"),
				Status:      types.StatusType("Active"),
				CreateDate:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListAccessKeys.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListAccessKeys(context.Background(), &ListAccessKeysInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListAccessKeys.response", err)
	}
}

func TestCheckResponseSnapshot_ListAccountAliases(t *testing.T) {
	want := &ListAccountAliasesOutput{
		AccountAliases: []string{
			"__Member__",
			"__Member__",
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListAccountAliases.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListAccountAliases(context.Background(), &ListAccountAliasesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListAccountAliases.response", err)
	}
}

func TestCheckResponseSnapshot_ListAttachedGroupPolicies(t *testing.T) {
	want := &ListAttachedGroupPoliciesOutput{
		AttachedPolicies: []types.AttachedPolicy{
			{
				PolicyName: ptr.String("__PolicyName__"),
				PolicyArn:  ptr.String("__PolicyArn__"),
			},
			{
				PolicyName: ptr.String("__PolicyName__"),
				PolicyArn:  ptr.String("__PolicyArn__"),
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListAttachedGroupPolicies.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListAttachedGroupPolicies(context.Background(), &ListAttachedGroupPoliciesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListAttachedGroupPolicies.response", err)
	}
}

func TestCheckResponseSnapshot_ListAttachedRolePolicies(t *testing.T) {
	want := &ListAttachedRolePoliciesOutput{
		AttachedPolicies: []types.AttachedPolicy{
			{
				PolicyName: ptr.String("__PolicyName__"),
				PolicyArn:  ptr.String("__PolicyArn__"),
			},
			{
				PolicyName: ptr.String("__PolicyName__"),
				PolicyArn:  ptr.String("__PolicyArn__"),
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListAttachedRolePolicies.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListAttachedRolePolicies(context.Background(), &ListAttachedRolePoliciesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListAttachedRolePolicies.response", err)
	}
}

func TestCheckResponseSnapshot_ListAttachedUserPolicies(t *testing.T) {
	want := &ListAttachedUserPoliciesOutput{
		AttachedPolicies: []types.AttachedPolicy{
			{
				PolicyName: ptr.String("__PolicyName__"),
				PolicyArn:  ptr.String("__PolicyArn__"),
			},
			{
				PolicyName: ptr.String("__PolicyName__"),
				PolicyArn:  ptr.String("__PolicyArn__"),
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListAttachedUserPolicies.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListAttachedUserPolicies(context.Background(), &ListAttachedUserPoliciesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListAttachedUserPolicies.response", err)
	}
}

func TestCheckResponseSnapshot_ListDelegationRequests(t *testing.T) {
	want := &ListDelegationRequestsOutput{
		DelegationRequests: []types.DelegationRequest{
			{
				DelegationRequestId: ptr.String("__DelegationRequestId__"),
				OwnerAccountId:      ptr.String("__OwnerAccountId__"),
				Description:         ptr.String("__Description__"),
				RequestMessage:      ptr.String("__RequestMessage__"),
				Permissions: &types.DelegationPermission{
					PolicyTemplateArn: ptr.String("__PolicyTemplateArn__"),
					Parameters: []types.PolicyParameter{
						{
							Name: ptr.String("__Name__"),
							Values: []string{
								"__Member__",
								"__Member__",
							},
							Type: types.PolicyParameterTypeEnum("string"),
						},
						{
							Name: ptr.String("__Name__"),
							Values: []string{
								"__Member__",
								"__Member__",
							},
							Type: types.PolicyParameterTypeEnum("string"),
						},
					},
				},
				PermissionPolicy: ptr.String("__PermissionPolicy__"),
				RolePermissionRestrictionArns: []string{
					"__Member__",
					"__Member__",
				},
				OwnerId:         ptr.String("__OwnerId__"),
				ApproverId:      ptr.String("__ApproverId__"),
				State:           types.StateType("UNASSIGNED"),
				ExpirationTime:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				RequestorId:     ptr.String("__RequestorId__"),
				RequestorName:   ptr.String("__RequestorName__"),
				CreateDate:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				SessionDuration: ptr.Int32(1),
				RedirectUrl:     ptr.String("__RedirectUrl__"),
				Notes:           ptr.String("__Notes__"),
				RejectionReason: ptr.String("__RejectionReason__"),
				OnlySendByOwner: true,
				UpdatedTime:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				DelegationRequestId: ptr.String("__DelegationRequestId__"),
				OwnerAccountId:      ptr.String("__OwnerAccountId__"),
				Description:         ptr.String("__Description__"),
				RequestMessage:      ptr.String("__RequestMessage__"),
				Permissions: &types.DelegationPermission{
					PolicyTemplateArn: ptr.String("__PolicyTemplateArn__"),
					Parameters: []types.PolicyParameter{
						{
							Name: ptr.String("__Name__"),
							Values: []string{
								"__Member__",
								"__Member__",
							},
							Type: types.PolicyParameterTypeEnum("string"),
						},
						{
							Name: ptr.String("__Name__"),
							Values: []string{
								"__Member__",
								"__Member__",
							},
							Type: types.PolicyParameterTypeEnum("string"),
						},
					},
				},
				PermissionPolicy: ptr.String("__PermissionPolicy__"),
				RolePermissionRestrictionArns: []string{
					"__Member__",
					"__Member__",
				},
				OwnerId:         ptr.String("__OwnerId__"),
				ApproverId:      ptr.String("__ApproverId__"),
				State:           types.StateType("UNASSIGNED"),
				ExpirationTime:  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				RequestorId:     ptr.String("__RequestorId__"),
				RequestorName:   ptr.String("__RequestorName__"),
				CreateDate:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				SessionDuration: ptr.Int32(1),
				RedirectUrl:     ptr.String("__RedirectUrl__"),
				Notes:           ptr.String("__Notes__"),
				RejectionReason: ptr.String("__RejectionReason__"),
				OnlySendByOwner: true,
				UpdatedTime:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		Marker:      ptr.String("__Marker__"),
		IsTruncated: true,
	}
	status, header, body, err := serdeRespReadSnapshot("ListDelegationRequests.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListDelegationRequests(context.Background(), &ListDelegationRequestsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListDelegationRequests.response", err)
	}
}

func TestCheckResponseSnapshot_ListEntitiesForPolicy(t *testing.T) {
	want := &ListEntitiesForPolicyOutput{
		PolicyGroups: []types.PolicyGroup{
			{
				GroupName: ptr.String("__GroupName__"),
				GroupId:   ptr.String("__GroupId__"),
			},
			{
				GroupName: ptr.String("__GroupName__"),
				GroupId:   ptr.String("__GroupId__"),
			},
		},
		PolicyUsers: []types.PolicyUser{
			{
				UserName: ptr.String("__UserName__"),
				UserId:   ptr.String("__UserId__"),
			},
			{
				UserName: ptr.String("__UserName__"),
				UserId:   ptr.String("__UserId__"),
			},
		},
		PolicyRoles: []types.PolicyRole{
			{
				RoleName: ptr.String("__RoleName__"),
				RoleId:   ptr.String("__RoleId__"),
			},
			{
				RoleName: ptr.String("__RoleName__"),
				RoleId:   ptr.String("__RoleId__"),
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListEntitiesForPolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListEntitiesForPolicy(context.Background(), &ListEntitiesForPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListEntitiesForPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_ListGroupPolicies(t *testing.T) {
	want := &ListGroupPoliciesOutput{
		PolicyNames: []string{
			"__Member__",
			"__Member__",
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListGroupPolicies.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListGroupPolicies(context.Background(), &ListGroupPoliciesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListGroupPolicies.response", err)
	}
}

func TestCheckResponseSnapshot_ListGroups(t *testing.T) {
	want := &ListGroupsOutput{
		Groups: []types.Group{
			{
				Path:       ptr.String("__Path__"),
				GroupName:  ptr.String("__GroupName__"),
				GroupId:    ptr.String("__GroupId__"),
				Arn:        ptr.String("__Arn__"),
				CreateDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				Path:       ptr.String("__Path__"),
				GroupName:  ptr.String("__GroupName__"),
				GroupId:    ptr.String("__GroupId__"),
				Arn:        ptr.String("__Arn__"),
				CreateDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListGroups.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListGroups(context.Background(), &ListGroupsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListGroups.response", err)
	}
}

func TestCheckResponseSnapshot_ListGroupsForUser(t *testing.T) {
	want := &ListGroupsForUserOutput{
		Groups: []types.Group{
			{
				Path:       ptr.String("__Path__"),
				GroupName:  ptr.String("__GroupName__"),
				GroupId:    ptr.String("__GroupId__"),
				Arn:        ptr.String("__Arn__"),
				CreateDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				Path:       ptr.String("__Path__"),
				GroupName:  ptr.String("__GroupName__"),
				GroupId:    ptr.String("__GroupId__"),
				Arn:        ptr.String("__Arn__"),
				CreateDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListGroupsForUser.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListGroupsForUser(context.Background(), &ListGroupsForUserInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListGroupsForUser.response", err)
	}
}

func TestCheckResponseSnapshot_ListInstanceProfileTags(t *testing.T) {
	want := &ListInstanceProfileTagsOutput{
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListInstanceProfileTags.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListInstanceProfileTags(context.Background(), &ListInstanceProfileTagsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListInstanceProfileTags.response", err)
	}
}

func TestCheckResponseSnapshot_ListInstanceProfiles(t *testing.T) {
	want := &ListInstanceProfilesOutput{
		InstanceProfiles: []types.InstanceProfile{
			{
				Path:                ptr.String("__Path__"),
				InstanceProfileName: ptr.String("__InstanceProfileName__"),
				InstanceProfileId:   ptr.String("__InstanceProfileId__"),
				Arn:                 ptr.String("__Arn__"),
				CreateDate:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Roles: []types.Role{
					{
						Path:                     ptr.String("__Path__"),
						RoleName:                 ptr.String("__RoleName__"),
						RoleId:                   ptr.String("__RoleId__"),
						Arn:                      ptr.String("__Arn__"),
						CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
						Description:              ptr.String("__Description__"),
						MaxSessionDuration:       ptr.Int32(1),
						PermissionsBoundary: &types.AttachedPermissionsBoundary{
							PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
							PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
						},
						Tags: []types.Tag{
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
						},
						RoleLastUsed: &types.RoleLastUsed{
							LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
							Region:       ptr.String("__Region__"),
						},
					},
					{
						Path:                     ptr.String("__Path__"),
						RoleName:                 ptr.String("__RoleName__"),
						RoleId:                   ptr.String("__RoleId__"),
						Arn:                      ptr.String("__Arn__"),
						CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
						Description:              ptr.String("__Description__"),
						MaxSessionDuration:       ptr.Int32(1),
						PermissionsBoundary: &types.AttachedPermissionsBoundary{
							PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
							PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
						},
						Tags: []types.Tag{
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
						},
						RoleLastUsed: &types.RoleLastUsed{
							LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
							Region:       ptr.String("__Region__"),
						},
					},
				},
				Tags: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
			},
			{
				Path:                ptr.String("__Path__"),
				InstanceProfileName: ptr.String("__InstanceProfileName__"),
				InstanceProfileId:   ptr.String("__InstanceProfileId__"),
				Arn:                 ptr.String("__Arn__"),
				CreateDate:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Roles: []types.Role{
					{
						Path:                     ptr.String("__Path__"),
						RoleName:                 ptr.String("__RoleName__"),
						RoleId:                   ptr.String("__RoleId__"),
						Arn:                      ptr.String("__Arn__"),
						CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
						Description:              ptr.String("__Description__"),
						MaxSessionDuration:       ptr.Int32(1),
						PermissionsBoundary: &types.AttachedPermissionsBoundary{
							PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
							PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
						},
						Tags: []types.Tag{
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
						},
						RoleLastUsed: &types.RoleLastUsed{
							LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
							Region:       ptr.String("__Region__"),
						},
					},
					{
						Path:                     ptr.String("__Path__"),
						RoleName:                 ptr.String("__RoleName__"),
						RoleId:                   ptr.String("__RoleId__"),
						Arn:                      ptr.String("__Arn__"),
						CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
						Description:              ptr.String("__Description__"),
						MaxSessionDuration:       ptr.Int32(1),
						PermissionsBoundary: &types.AttachedPermissionsBoundary{
							PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
							PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
						},
						Tags: []types.Tag{
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
						},
						RoleLastUsed: &types.RoleLastUsed{
							LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
							Region:       ptr.String("__Region__"),
						},
					},
				},
				Tags: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListInstanceProfiles.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListInstanceProfiles(context.Background(), &ListInstanceProfilesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListInstanceProfiles.response", err)
	}
}

func TestCheckResponseSnapshot_ListInstanceProfilesForRole(t *testing.T) {
	want := &ListInstanceProfilesForRoleOutput{
		InstanceProfiles: []types.InstanceProfile{
			{
				Path:                ptr.String("__Path__"),
				InstanceProfileName: ptr.String("__InstanceProfileName__"),
				InstanceProfileId:   ptr.String("__InstanceProfileId__"),
				Arn:                 ptr.String("__Arn__"),
				CreateDate:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Roles: []types.Role{
					{
						Path:                     ptr.String("__Path__"),
						RoleName:                 ptr.String("__RoleName__"),
						RoleId:                   ptr.String("__RoleId__"),
						Arn:                      ptr.String("__Arn__"),
						CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
						Description:              ptr.String("__Description__"),
						MaxSessionDuration:       ptr.Int32(1),
						PermissionsBoundary: &types.AttachedPermissionsBoundary{
							PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
							PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
						},
						Tags: []types.Tag{
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
						},
						RoleLastUsed: &types.RoleLastUsed{
							LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
							Region:       ptr.String("__Region__"),
						},
					},
					{
						Path:                     ptr.String("__Path__"),
						RoleName:                 ptr.String("__RoleName__"),
						RoleId:                   ptr.String("__RoleId__"),
						Arn:                      ptr.String("__Arn__"),
						CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
						Description:              ptr.String("__Description__"),
						MaxSessionDuration:       ptr.Int32(1),
						PermissionsBoundary: &types.AttachedPermissionsBoundary{
							PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
							PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
						},
						Tags: []types.Tag{
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
						},
						RoleLastUsed: &types.RoleLastUsed{
							LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
							Region:       ptr.String("__Region__"),
						},
					},
				},
				Tags: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
			},
			{
				Path:                ptr.String("__Path__"),
				InstanceProfileName: ptr.String("__InstanceProfileName__"),
				InstanceProfileId:   ptr.String("__InstanceProfileId__"),
				Arn:                 ptr.String("__Arn__"),
				CreateDate:          ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Roles: []types.Role{
					{
						Path:                     ptr.String("__Path__"),
						RoleName:                 ptr.String("__RoleName__"),
						RoleId:                   ptr.String("__RoleId__"),
						Arn:                      ptr.String("__Arn__"),
						CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
						Description:              ptr.String("__Description__"),
						MaxSessionDuration:       ptr.Int32(1),
						PermissionsBoundary: &types.AttachedPermissionsBoundary{
							PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
							PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
						},
						Tags: []types.Tag{
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
						},
						RoleLastUsed: &types.RoleLastUsed{
							LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
							Region:       ptr.String("__Region__"),
						},
					},
					{
						Path:                     ptr.String("__Path__"),
						RoleName:                 ptr.String("__RoleName__"),
						RoleId:                   ptr.String("__RoleId__"),
						Arn:                      ptr.String("__Arn__"),
						CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
						AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
						Description:              ptr.String("__Description__"),
						MaxSessionDuration:       ptr.Int32(1),
						PermissionsBoundary: &types.AttachedPermissionsBoundary{
							PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
							PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
						},
						Tags: []types.Tag{
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
							{
								Key:   ptr.String("__Key__"),
								Value: ptr.String("__Value__"),
							},
						},
						RoleLastUsed: &types.RoleLastUsed{
							LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
							Region:       ptr.String("__Region__"),
						},
					},
				},
				Tags: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListInstanceProfilesForRole.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListInstanceProfilesForRole(context.Background(), &ListInstanceProfilesForRoleInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListInstanceProfilesForRole.response", err)
	}
}

func TestCheckResponseSnapshot_ListMFADeviceTags(t *testing.T) {
	want := &ListMFADeviceTagsOutput{
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListMFADeviceTags.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListMFADeviceTags(context.Background(), &ListMFADeviceTagsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListMFADeviceTags.response", err)
	}
}

func TestCheckResponseSnapshot_ListMFADevices(t *testing.T) {
	want := &ListMFADevicesOutput{
		MFADevices: []types.MFADevice{
			{
				UserName:     ptr.String("__UserName__"),
				SerialNumber: ptr.String("__SerialNumber__"),
				EnableDate:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				UserName:     ptr.String("__UserName__"),
				SerialNumber: ptr.String("__SerialNumber__"),
				EnableDate:   ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListMFADevices.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListMFADevices(context.Background(), &ListMFADevicesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListMFADevices.response", err)
	}
}

func TestCheckResponseSnapshot_ListOpenIDConnectProviderTags(t *testing.T) {
	want := &ListOpenIDConnectProviderTagsOutput{
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListOpenIDConnectProviderTags.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListOpenIDConnectProviderTags(context.Background(), &ListOpenIDConnectProviderTagsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListOpenIDConnectProviderTags.response", err)
	}
}

func TestCheckResponseSnapshot_ListOpenIDConnectProviders(t *testing.T) {
	want := &ListOpenIDConnectProvidersOutput{
		OpenIDConnectProviderList: []types.OpenIDConnectProviderListEntry{
			{
				Arn: ptr.String("__Arn__"),
			},
			{
				Arn: ptr.String("__Arn__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListOpenIDConnectProviders.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListOpenIDConnectProviders(context.Background(), &ListOpenIDConnectProvidersInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListOpenIDConnectProviders.response", err)
	}
}

func TestCheckResponseSnapshot_ListOrganizationsFeatures(t *testing.T) {
	want := &ListOrganizationsFeaturesOutput{
		OrganizationId: ptr.String("__OrganizationId__"),
		EnabledFeatures: []types.FeatureType{
			types.FeatureType("RootCredentialsManagement"),
			types.FeatureType("RootCredentialsManagement"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListOrganizationsFeatures.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListOrganizationsFeatures(context.Background(), &ListOrganizationsFeaturesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListOrganizationsFeatures.response", err)
	}
}

func TestCheckResponseSnapshot_ListPolicies(t *testing.T) {
	want := &ListPoliciesOutput{
		Policies: []types.Policy{
			{
				PolicyName:                    ptr.String("__PolicyName__"),
				PolicyId:                      ptr.String("__PolicyId__"),
				Arn:                           ptr.String("__Arn__"),
				Path:                          ptr.String("__Path__"),
				DefaultVersionId:              ptr.String("__DefaultVersionId__"),
				AttachmentCount:               ptr.Int32(1),
				PermissionsBoundaryUsageCount: ptr.Int32(1),
				IsAttachable:                  true,
				Description:                   ptr.String("__Description__"),
				CreateDate:                    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdateDate:                    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Tags: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
			},
			{
				PolicyName:                    ptr.String("__PolicyName__"),
				PolicyId:                      ptr.String("__PolicyId__"),
				Arn:                           ptr.String("__Arn__"),
				Path:                          ptr.String("__Path__"),
				DefaultVersionId:              ptr.String("__DefaultVersionId__"),
				AttachmentCount:               ptr.Int32(1),
				PermissionsBoundaryUsageCount: ptr.Int32(1),
				IsAttachable:                  true,
				Description:                   ptr.String("__Description__"),
				CreateDate:                    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				UpdateDate:                    ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Tags: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListPolicies.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListPolicies(context.Background(), &ListPoliciesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListPolicies.response", err)
	}
}

func TestCheckResponseSnapshot_ListPoliciesGrantingServiceAccess(t *testing.T) {
	want := &ListPoliciesGrantingServiceAccessOutput{
		PoliciesGrantingServiceAccess: []types.ListPoliciesGrantingServiceAccessEntry{
			{
				ServiceNamespace: ptr.String("__ServiceNamespace__"),
				Policies: []types.PolicyGrantingServiceAccess{
					{
						PolicyName: ptr.String("__PolicyName__"),
						PolicyType: types.PolicyType("INLINE"),
						PolicyArn:  ptr.String("__PolicyArn__"),
						EntityType: types.PolicyOwnerEntityType("USER"),
						EntityName: ptr.String("__EntityName__"),
					},
					{
						PolicyName: ptr.String("__PolicyName__"),
						PolicyType: types.PolicyType("INLINE"),
						PolicyArn:  ptr.String("__PolicyArn__"),
						EntityType: types.PolicyOwnerEntityType("USER"),
						EntityName: ptr.String("__EntityName__"),
					},
				},
			},
			{
				ServiceNamespace: ptr.String("__ServiceNamespace__"),
				Policies: []types.PolicyGrantingServiceAccess{
					{
						PolicyName: ptr.String("__PolicyName__"),
						PolicyType: types.PolicyType("INLINE"),
						PolicyArn:  ptr.String("__PolicyArn__"),
						EntityType: types.PolicyOwnerEntityType("USER"),
						EntityName: ptr.String("__EntityName__"),
					},
					{
						PolicyName: ptr.String("__PolicyName__"),
						PolicyType: types.PolicyType("INLINE"),
						PolicyArn:  ptr.String("__PolicyArn__"),
						EntityType: types.PolicyOwnerEntityType("USER"),
						EntityName: ptr.String("__EntityName__"),
					},
				},
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListPoliciesGrantingServiceAccess.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListPoliciesGrantingServiceAccess(context.Background(), &ListPoliciesGrantingServiceAccessInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListPoliciesGrantingServiceAccess.response", err)
	}
}

func TestCheckResponseSnapshot_ListPolicyTags(t *testing.T) {
	want := &ListPolicyTagsOutput{
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListPolicyTags.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListPolicyTags(context.Background(), &ListPolicyTagsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListPolicyTags.response", err)
	}
}

func TestCheckResponseSnapshot_ListPolicyVersions(t *testing.T) {
	want := &ListPolicyVersionsOutput{
		Versions: []types.PolicyVersion{
			{
				Document:         ptr.String("__Document__"),
				VersionId:        ptr.String("__VersionId__"),
				IsDefaultVersion: true,
				CreateDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				Document:         ptr.String("__Document__"),
				VersionId:        ptr.String("__VersionId__"),
				IsDefaultVersion: true,
				CreateDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListPolicyVersions.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListPolicyVersions(context.Background(), &ListPolicyVersionsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListPolicyVersions.response", err)
	}
}

func TestCheckResponseSnapshot_ListRolePolicies(t *testing.T) {
	want := &ListRolePoliciesOutput{
		PolicyNames: []string{
			"__Member__",
			"__Member__",
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListRolePolicies.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListRolePolicies(context.Background(), &ListRolePoliciesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListRolePolicies.response", err)
	}
}

func TestCheckResponseSnapshot_ListRoleTags(t *testing.T) {
	want := &ListRoleTagsOutput{
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListRoleTags.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListRoleTags(context.Background(), &ListRoleTagsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListRoleTags.response", err)
	}
}

func TestCheckResponseSnapshot_ListRoles(t *testing.T) {
	want := &ListRolesOutput{
		Roles: []types.Role{
			{
				Path:                     ptr.String("__Path__"),
				RoleName:                 ptr.String("__RoleName__"),
				RoleId:                   ptr.String("__RoleId__"),
				Arn:                      ptr.String("__Arn__"),
				CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
				Description:              ptr.String("__Description__"),
				MaxSessionDuration:       ptr.Int32(1),
				PermissionsBoundary: &types.AttachedPermissionsBoundary{
					PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
					PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
				},
				Tags: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
				RoleLastUsed: &types.RoleLastUsed{
					LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					Region:       ptr.String("__Region__"),
				},
			},
			{
				Path:                     ptr.String("__Path__"),
				RoleName:                 ptr.String("__RoleName__"),
				RoleId:                   ptr.String("__RoleId__"),
				Arn:                      ptr.String("__Arn__"),
				CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
				Description:              ptr.String("__Description__"),
				MaxSessionDuration:       ptr.Int32(1),
				PermissionsBoundary: &types.AttachedPermissionsBoundary{
					PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
					PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
				},
				Tags: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
				RoleLastUsed: &types.RoleLastUsed{
					LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					Region:       ptr.String("__Region__"),
				},
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListRoles.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListRoles(context.Background(), &ListRolesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListRoles.response", err)
	}
}

func TestCheckResponseSnapshot_ListSAMLProviderTags(t *testing.T) {
	want := &ListSAMLProviderTagsOutput{
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListSAMLProviderTags.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListSAMLProviderTags(context.Background(), &ListSAMLProviderTagsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListSAMLProviderTags.response", err)
	}
}

func TestCheckResponseSnapshot_ListSAMLProviders(t *testing.T) {
	want := &ListSAMLProvidersOutput{
		SAMLProviderList: []types.SAMLProviderListEntry{
			{
				Arn:        ptr.String("__Arn__"),
				ValidUntil: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				CreateDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				Arn:        ptr.String("__Arn__"),
				ValidUntil: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				CreateDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ListSAMLProviders.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListSAMLProviders(context.Background(), &ListSAMLProvidersInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListSAMLProviders.response", err)
	}
}

func TestCheckResponseSnapshot_ListSSHPublicKeys(t *testing.T) {
	want := &ListSSHPublicKeysOutput{
		SSHPublicKeys: []types.SSHPublicKeyMetadata{
			{
				UserName:       ptr.String("__UserName__"),
				SSHPublicKeyId: ptr.String("__SSHPublicKeyId__"),
				Status:         types.StatusType("Active"),
				UploadDate:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				UserName:       ptr.String("__UserName__"),
				SSHPublicKeyId: ptr.String("__SSHPublicKeyId__"),
				Status:         types.StatusType("Active"),
				UploadDate:     ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListSSHPublicKeys.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListSSHPublicKeys(context.Background(), &ListSSHPublicKeysInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListSSHPublicKeys.response", err)
	}
}

func TestCheckResponseSnapshot_ListServerCertificateTags(t *testing.T) {
	want := &ListServerCertificateTagsOutput{
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListServerCertificateTags.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListServerCertificateTags(context.Background(), &ListServerCertificateTagsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListServerCertificateTags.response", err)
	}
}

func TestCheckResponseSnapshot_ListServerCertificates(t *testing.T) {
	want := &ListServerCertificatesOutput{
		ServerCertificateMetadataList: []types.ServerCertificateMetadata{
			{
				Path:                  ptr.String("__Path__"),
				ServerCertificateName: ptr.String("__ServerCertificateName__"),
				ServerCertificateId:   ptr.String("__ServerCertificateId__"),
				Arn:                   ptr.String("__Arn__"),
				UploadDate:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Expiration:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				Path:                  ptr.String("__Path__"),
				ServerCertificateName: ptr.String("__ServerCertificateName__"),
				ServerCertificateId:   ptr.String("__ServerCertificateId__"),
				Arn:                   ptr.String("__Arn__"),
				UploadDate:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Expiration:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListServerCertificates.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListServerCertificates(context.Background(), &ListServerCertificatesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListServerCertificates.response", err)
	}
}

func TestCheckResponseSnapshot_ListServiceSpecificCredentials(t *testing.T) {
	want := &ListServiceSpecificCredentialsOutput{
		ServiceSpecificCredentials: []types.ServiceSpecificCredentialMetadata{
			{
				UserName:                    ptr.String("__UserName__"),
				Status:                      types.StatusType("Active"),
				ServiceUserName:             ptr.String("__ServiceUserName__"),
				ServiceCredentialAlias:      ptr.String("__ServiceCredentialAlias__"),
				CreateDate:                  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ExpirationDate:              ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ServiceSpecificCredentialId: ptr.String("__ServiceSpecificCredentialId__"),
				ServiceName:                 ptr.String("__ServiceName__"),
			},
			{
				UserName:                    ptr.String("__UserName__"),
				Status:                      types.StatusType("Active"),
				ServiceUserName:             ptr.String("__ServiceUserName__"),
				ServiceCredentialAlias:      ptr.String("__ServiceCredentialAlias__"),
				CreateDate:                  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ExpirationDate:              ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				ServiceSpecificCredentialId: ptr.String("__ServiceSpecificCredentialId__"),
				ServiceName:                 ptr.String("__ServiceName__"),
			},
		},
		Marker:      ptr.String("__Marker__"),
		IsTruncated: true,
	}
	status, header, body, err := serdeRespReadSnapshot("ListServiceSpecificCredentials.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListServiceSpecificCredentials(context.Background(), &ListServiceSpecificCredentialsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListServiceSpecificCredentials.response", err)
	}
}

func TestCheckResponseSnapshot_ListSigningCertificates(t *testing.T) {
	want := &ListSigningCertificatesOutput{
		Certificates: []types.SigningCertificate{
			{
				UserName:        ptr.String("__UserName__"),
				CertificateId:   ptr.String("__CertificateId__"),
				CertificateBody: ptr.String("__CertificateBody__"),
				Status:          types.StatusType("Active"),
				UploadDate:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
			{
				UserName:        ptr.String("__UserName__"),
				CertificateId:   ptr.String("__CertificateId__"),
				CertificateBody: ptr.String("__CertificateBody__"),
				Status:          types.StatusType("Active"),
				UploadDate:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListSigningCertificates.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListSigningCertificates(context.Background(), &ListSigningCertificatesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListSigningCertificates.response", err)
	}
}

func TestCheckResponseSnapshot_ListUserPolicies(t *testing.T) {
	want := &ListUserPoliciesOutput{
		PolicyNames: []string{
			"__Member__",
			"__Member__",
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListUserPolicies.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListUserPolicies(context.Background(), &ListUserPoliciesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListUserPolicies.response", err)
	}
}

func TestCheckResponseSnapshot_ListUserTags(t *testing.T) {
	want := &ListUserTagsOutput{
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListUserTags.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListUserTags(context.Background(), &ListUserTagsInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListUserTags.response", err)
	}
}

func TestCheckResponseSnapshot_ListUsers(t *testing.T) {
	want := &ListUsersOutput{
		Users: []types.User{
			{
				Path:             ptr.String("__Path__"),
				UserName:         ptr.String("__UserName__"),
				UserId:           ptr.String("__UserId__"),
				Arn:              ptr.String("__Arn__"),
				CreateDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PasswordLastUsed: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PermissionsBoundary: &types.AttachedPermissionsBoundary{
					PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
					PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
				},
				Tags: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
			},
			{
				Path:             ptr.String("__Path__"),
				UserName:         ptr.String("__UserName__"),
				UserId:           ptr.String("__UserId__"),
				Arn:              ptr.String("__Arn__"),
				CreateDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PasswordLastUsed: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				PermissionsBoundary: &types.AttachedPermissionsBoundary{
					PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
					PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
				},
				Tags: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListUsers.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListUsers(context.Background(), &ListUsersInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListUsers.response", err)
	}
}

func TestCheckResponseSnapshot_ListVirtualMFADevices(t *testing.T) {
	want := &ListVirtualMFADevicesOutput{
		VirtualMFADevices: []types.VirtualMFADevice{
			{
				SerialNumber:     ptr.String("__SerialNumber__"),
				Base32StringSeed: []byte("blob"),
				QRCodePNG:        []byte("blob"),
				User: &types.User{
					Path:             ptr.String("__Path__"),
					UserName:         ptr.String("__UserName__"),
					UserId:           ptr.String("__UserId__"),
					Arn:              ptr.String("__Arn__"),
					CreateDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					PasswordLastUsed: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					PermissionsBoundary: &types.AttachedPermissionsBoundary{
						PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
						PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
					},
					Tags: []types.Tag{
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
					},
				},
				EnableDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Tags: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
			},
			{
				SerialNumber:     ptr.String("__SerialNumber__"),
				Base32StringSeed: []byte("blob"),
				QRCodePNG:        []byte("blob"),
				User: &types.User{
					Path:             ptr.String("__Path__"),
					UserName:         ptr.String("__UserName__"),
					UserId:           ptr.String("__UserId__"),
					Arn:              ptr.String("__Arn__"),
					CreateDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					PasswordLastUsed: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
					PermissionsBoundary: &types.AttachedPermissionsBoundary{
						PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
						PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
					},
					Tags: []types.Tag{
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
						{
							Key:   ptr.String("__Key__"),
							Value: ptr.String("__Value__"),
						},
					},
				},
				EnableDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Tags: []types.Tag{
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
					{
						Key:   ptr.String("__Key__"),
						Value: ptr.String("__Value__"),
					},
				},
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ListVirtualMFADevices.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ListVirtualMFADevices(context.Background(), &ListVirtualMFADevicesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ListVirtualMFADevices.response", err)
	}
}

func TestCheckResponseSnapshot_PutGroupPolicy(t *testing.T) {
	want := &PutGroupPolicyOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutGroupPolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutGroupPolicy(context.Background(), &PutGroupPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutGroupPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_PutRolePermissionsBoundary(t *testing.T) {
	want := &PutRolePermissionsBoundaryOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutRolePermissionsBoundary.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutRolePermissionsBoundary(context.Background(), &PutRolePermissionsBoundaryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutRolePermissionsBoundary.response", err)
	}
}

func TestCheckResponseSnapshot_PutRolePolicy(t *testing.T) {
	want := &PutRolePolicyOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutRolePolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutRolePolicy(context.Background(), &PutRolePolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutRolePolicy.response", err)
	}
}

func TestCheckResponseSnapshot_PutUserPermissionsBoundary(t *testing.T) {
	want := &PutUserPermissionsBoundaryOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutUserPermissionsBoundary.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutUserPermissionsBoundary(context.Background(), &PutUserPermissionsBoundaryInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutUserPermissionsBoundary.response", err)
	}
}

func TestCheckResponseSnapshot_PutUserPolicy(t *testing.T) {
	want := &PutUserPolicyOutput{}
	status, header, body, err := serdeRespReadSnapshot("PutUserPolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.PutUserPolicy(context.Background(), &PutUserPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "PutUserPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_RejectDelegationRequest(t *testing.T) {
	want := &RejectDelegationRequestOutput{}
	status, header, body, err := serdeRespReadSnapshot("RejectDelegationRequest.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.RejectDelegationRequest(context.Background(), &RejectDelegationRequestInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "RejectDelegationRequest.response", err)
	}
}

func TestCheckResponseSnapshot_RemoveClientIDFromOpenIDConnectProvider(t *testing.T) {
	want := &RemoveClientIDFromOpenIDConnectProviderOutput{}
	status, header, body, err := serdeRespReadSnapshot("RemoveClientIDFromOpenIDConnectProvider.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.RemoveClientIDFromOpenIDConnectProvider(context.Background(), &RemoveClientIDFromOpenIDConnectProviderInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "RemoveClientIDFromOpenIDConnectProvider.response", err)
	}
}

func TestCheckResponseSnapshot_RemoveRoleFromInstanceProfile(t *testing.T) {
	want := &RemoveRoleFromInstanceProfileOutput{}
	status, header, body, err := serdeRespReadSnapshot("RemoveRoleFromInstanceProfile.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.RemoveRoleFromInstanceProfile(context.Background(), &RemoveRoleFromInstanceProfileInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "RemoveRoleFromInstanceProfile.response", err)
	}
}

func TestCheckResponseSnapshot_RemoveUserFromGroup(t *testing.T) {
	want := &RemoveUserFromGroupOutput{}
	status, header, body, err := serdeRespReadSnapshot("RemoveUserFromGroup.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.RemoveUserFromGroup(context.Background(), &RemoveUserFromGroupInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "RemoveUserFromGroup.response", err)
	}
}

func TestCheckResponseSnapshot_ResetServiceSpecificCredential(t *testing.T) {
	want := &ResetServiceSpecificCredentialOutput{
		ServiceSpecificCredential: &types.ServiceSpecificCredential{
			CreateDate:                  ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			ExpirationDate:              ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			ServiceName:                 ptr.String("__ServiceName__"),
			ServiceUserName:             ptr.String("__ServiceUserName__"),
			ServicePassword:             ptr.String("__ServicePassword__"),
			ServiceCredentialAlias:      ptr.String("__ServiceCredentialAlias__"),
			ServiceCredentialSecret:     ptr.String("__ServiceCredentialSecret__"),
			ServiceSpecificCredentialId: ptr.String("__ServiceSpecificCredentialId__"),
			UserName:                    ptr.String("__UserName__"),
			Status:                      types.StatusType("Active"),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("ResetServiceSpecificCredential.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ResetServiceSpecificCredential(context.Background(), &ResetServiceSpecificCredentialInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ResetServiceSpecificCredential.response", err)
	}
}

func TestCheckResponseSnapshot_ResyncMFADevice(t *testing.T) {
	want := &ResyncMFADeviceOutput{}
	status, header, body, err := serdeRespReadSnapshot("ResyncMFADevice.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.ResyncMFADevice(context.Background(), &ResyncMFADeviceInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "ResyncMFADevice.response", err)
	}
}

func TestCheckResponseSnapshot_SendDelegationToken(t *testing.T) {
	want := &SendDelegationTokenOutput{}
	status, header, body, err := serdeRespReadSnapshot("SendDelegationToken.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.SendDelegationToken(context.Background(), &SendDelegationTokenInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "SendDelegationToken.response", err)
	}
}

func TestCheckResponseSnapshot_SetDefaultPolicyVersion(t *testing.T) {
	want := &SetDefaultPolicyVersionOutput{}
	status, header, body, err := serdeRespReadSnapshot("SetDefaultPolicyVersion.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.SetDefaultPolicyVersion(context.Background(), &SetDefaultPolicyVersionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "SetDefaultPolicyVersion.response", err)
	}
}

func TestCheckResponseSnapshot_SetSecurityTokenServicePreferences(t *testing.T) {
	want := &SetSecurityTokenServicePreferencesOutput{}
	status, header, body, err := serdeRespReadSnapshot("SetSecurityTokenServicePreferences.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.SetSecurityTokenServicePreferences(context.Background(), &SetSecurityTokenServicePreferencesInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "SetSecurityTokenServicePreferences.response", err)
	}
}

func TestCheckResponseSnapshot_SimulateCustomPolicy(t *testing.T) {
	want := &SimulateCustomPolicyOutput{
		EvaluationResults: []types.EvaluationResult{
			{
				EvalActionName:   ptr.String("__EvalActionName__"),
				EvalResourceName: ptr.String("__EvalResourceName__"),
				EvalDecision:     types.PolicyEvaluationDecisionType("allowed"),
				MatchedStatements: []types.Statement{
					{
						SourcePolicyId:   ptr.String("__SourcePolicyId__"),
						SourcePolicyType: types.PolicySourceType("user"),
						StartPosition: &types.Position{
							Line:   1,
							Column: 1,
						},
						EndPosition: &types.Position{
							Line:   1,
							Column: 1,
						},
					},
					{
						SourcePolicyId:   ptr.String("__SourcePolicyId__"),
						SourcePolicyType: types.PolicySourceType("user"),
						StartPosition: &types.Position{
							Line:   1,
							Column: 1,
						},
						EndPosition: &types.Position{
							Line:   1,
							Column: 1,
						},
					},
				},
				MissingContextValues: []string{
					"__Member__",
					"__Member__",
				},
				OrganizationsDecisionDetail: &types.OrganizationsDecisionDetail{
					AllowedByOrganizations: true,
				},
				PermissionsBoundaryDecisionDetail: &types.PermissionsBoundaryDecisionDetail{
					AllowedByPermissionsBoundary: true,
				},
				EvalDecisionDetails: map[string]types.PolicyEvaluationDecisionType{
					"key0": types.PolicyEvaluationDecisionType("allowed"),
				},
				ResourceSpecificResults: []types.ResourceSpecificResult{
					{
						EvalResourceName:     ptr.String("__EvalResourceName__"),
						EvalResourceDecision: types.PolicyEvaluationDecisionType("allowed"),
						MatchedStatements: []types.Statement{
							{
								SourcePolicyId:   ptr.String("__SourcePolicyId__"),
								SourcePolicyType: types.PolicySourceType("user"),
								StartPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
								EndPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
							},
							{
								SourcePolicyId:   ptr.String("__SourcePolicyId__"),
								SourcePolicyType: types.PolicySourceType("user"),
								StartPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
								EndPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
							},
						},
						MissingContextValues: []string{
							"__Member__",
							"__Member__",
						},
						EvalDecisionDetails: map[string]types.PolicyEvaluationDecisionType{
							"key0": types.PolicyEvaluationDecisionType("allowed"),
						},
						PermissionsBoundaryDecisionDetail: &types.PermissionsBoundaryDecisionDetail{
							AllowedByPermissionsBoundary: true,
						},
					},
					{
						EvalResourceName:     ptr.String("__EvalResourceName__"),
						EvalResourceDecision: types.PolicyEvaluationDecisionType("allowed"),
						MatchedStatements: []types.Statement{
							{
								SourcePolicyId:   ptr.String("__SourcePolicyId__"),
								SourcePolicyType: types.PolicySourceType("user"),
								StartPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
								EndPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
							},
							{
								SourcePolicyId:   ptr.String("__SourcePolicyId__"),
								SourcePolicyType: types.PolicySourceType("user"),
								StartPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
								EndPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
							},
						},
						MissingContextValues: []string{
							"__Member__",
							"__Member__",
						},
						EvalDecisionDetails: map[string]types.PolicyEvaluationDecisionType{
							"key0": types.PolicyEvaluationDecisionType("allowed"),
						},
						PermissionsBoundaryDecisionDetail: &types.PermissionsBoundaryDecisionDetail{
							AllowedByPermissionsBoundary: true,
						},
					},
				},
			},
			{
				EvalActionName:   ptr.String("__EvalActionName__"),
				EvalResourceName: ptr.String("__EvalResourceName__"),
				EvalDecision:     types.PolicyEvaluationDecisionType("allowed"),
				MatchedStatements: []types.Statement{
					{
						SourcePolicyId:   ptr.String("__SourcePolicyId__"),
						SourcePolicyType: types.PolicySourceType("user"),
						StartPosition: &types.Position{
							Line:   1,
							Column: 1,
						},
						EndPosition: &types.Position{
							Line:   1,
							Column: 1,
						},
					},
					{
						SourcePolicyId:   ptr.String("__SourcePolicyId__"),
						SourcePolicyType: types.PolicySourceType("user"),
						StartPosition: &types.Position{
							Line:   1,
							Column: 1,
						},
						EndPosition: &types.Position{
							Line:   1,
							Column: 1,
						},
					},
				},
				MissingContextValues: []string{
					"__Member__",
					"__Member__",
				},
				OrganizationsDecisionDetail: &types.OrganizationsDecisionDetail{
					AllowedByOrganizations: true,
				},
				PermissionsBoundaryDecisionDetail: &types.PermissionsBoundaryDecisionDetail{
					AllowedByPermissionsBoundary: true,
				},
				EvalDecisionDetails: map[string]types.PolicyEvaluationDecisionType{
					"key0": types.PolicyEvaluationDecisionType("allowed"),
				},
				ResourceSpecificResults: []types.ResourceSpecificResult{
					{
						EvalResourceName:     ptr.String("__EvalResourceName__"),
						EvalResourceDecision: types.PolicyEvaluationDecisionType("allowed"),
						MatchedStatements: []types.Statement{
							{
								SourcePolicyId:   ptr.String("__SourcePolicyId__"),
								SourcePolicyType: types.PolicySourceType("user"),
								StartPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
								EndPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
							},
							{
								SourcePolicyId:   ptr.String("__SourcePolicyId__"),
								SourcePolicyType: types.PolicySourceType("user"),
								StartPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
								EndPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
							},
						},
						MissingContextValues: []string{
							"__Member__",
							"__Member__",
						},
						EvalDecisionDetails: map[string]types.PolicyEvaluationDecisionType{
							"key0": types.PolicyEvaluationDecisionType("allowed"),
						},
						PermissionsBoundaryDecisionDetail: &types.PermissionsBoundaryDecisionDetail{
							AllowedByPermissionsBoundary: true,
						},
					},
					{
						EvalResourceName:     ptr.String("__EvalResourceName__"),
						EvalResourceDecision: types.PolicyEvaluationDecisionType("allowed"),
						MatchedStatements: []types.Statement{
							{
								SourcePolicyId:   ptr.String("__SourcePolicyId__"),
								SourcePolicyType: types.PolicySourceType("user"),
								StartPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
								EndPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
							},
							{
								SourcePolicyId:   ptr.String("__SourcePolicyId__"),
								SourcePolicyType: types.PolicySourceType("user"),
								StartPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
								EndPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
							},
						},
						MissingContextValues: []string{
							"__Member__",
							"__Member__",
						},
						EvalDecisionDetails: map[string]types.PolicyEvaluationDecisionType{
							"key0": types.PolicyEvaluationDecisionType("allowed"),
						},
						PermissionsBoundaryDecisionDetail: &types.PermissionsBoundaryDecisionDetail{
							AllowedByPermissionsBoundary: true,
						},
					},
				},
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("SimulateCustomPolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.SimulateCustomPolicy(context.Background(), &SimulateCustomPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "SimulateCustomPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_SimulatePrincipalPolicy(t *testing.T) {
	want := &SimulatePrincipalPolicyOutput{
		EvaluationResults: []types.EvaluationResult{
			{
				EvalActionName:   ptr.String("__EvalActionName__"),
				EvalResourceName: ptr.String("__EvalResourceName__"),
				EvalDecision:     types.PolicyEvaluationDecisionType("allowed"),
				MatchedStatements: []types.Statement{
					{
						SourcePolicyId:   ptr.String("__SourcePolicyId__"),
						SourcePolicyType: types.PolicySourceType("user"),
						StartPosition: &types.Position{
							Line:   1,
							Column: 1,
						},
						EndPosition: &types.Position{
							Line:   1,
							Column: 1,
						},
					},
					{
						SourcePolicyId:   ptr.String("__SourcePolicyId__"),
						SourcePolicyType: types.PolicySourceType("user"),
						StartPosition: &types.Position{
							Line:   1,
							Column: 1,
						},
						EndPosition: &types.Position{
							Line:   1,
							Column: 1,
						},
					},
				},
				MissingContextValues: []string{
					"__Member__",
					"__Member__",
				},
				OrganizationsDecisionDetail: &types.OrganizationsDecisionDetail{
					AllowedByOrganizations: true,
				},
				PermissionsBoundaryDecisionDetail: &types.PermissionsBoundaryDecisionDetail{
					AllowedByPermissionsBoundary: true,
				},
				EvalDecisionDetails: map[string]types.PolicyEvaluationDecisionType{
					"key0": types.PolicyEvaluationDecisionType("allowed"),
				},
				ResourceSpecificResults: []types.ResourceSpecificResult{
					{
						EvalResourceName:     ptr.String("__EvalResourceName__"),
						EvalResourceDecision: types.PolicyEvaluationDecisionType("allowed"),
						MatchedStatements: []types.Statement{
							{
								SourcePolicyId:   ptr.String("__SourcePolicyId__"),
								SourcePolicyType: types.PolicySourceType("user"),
								StartPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
								EndPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
							},
							{
								SourcePolicyId:   ptr.String("__SourcePolicyId__"),
								SourcePolicyType: types.PolicySourceType("user"),
								StartPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
								EndPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
							},
						},
						MissingContextValues: []string{
							"__Member__",
							"__Member__",
						},
						EvalDecisionDetails: map[string]types.PolicyEvaluationDecisionType{
							"key0": types.PolicyEvaluationDecisionType("allowed"),
						},
						PermissionsBoundaryDecisionDetail: &types.PermissionsBoundaryDecisionDetail{
							AllowedByPermissionsBoundary: true,
						},
					},
					{
						EvalResourceName:     ptr.String("__EvalResourceName__"),
						EvalResourceDecision: types.PolicyEvaluationDecisionType("allowed"),
						MatchedStatements: []types.Statement{
							{
								SourcePolicyId:   ptr.String("__SourcePolicyId__"),
								SourcePolicyType: types.PolicySourceType("user"),
								StartPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
								EndPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
							},
							{
								SourcePolicyId:   ptr.String("__SourcePolicyId__"),
								SourcePolicyType: types.PolicySourceType("user"),
								StartPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
								EndPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
							},
						},
						MissingContextValues: []string{
							"__Member__",
							"__Member__",
						},
						EvalDecisionDetails: map[string]types.PolicyEvaluationDecisionType{
							"key0": types.PolicyEvaluationDecisionType("allowed"),
						},
						PermissionsBoundaryDecisionDetail: &types.PermissionsBoundaryDecisionDetail{
							AllowedByPermissionsBoundary: true,
						},
					},
				},
			},
			{
				EvalActionName:   ptr.String("__EvalActionName__"),
				EvalResourceName: ptr.String("__EvalResourceName__"),
				EvalDecision:     types.PolicyEvaluationDecisionType("allowed"),
				MatchedStatements: []types.Statement{
					{
						SourcePolicyId:   ptr.String("__SourcePolicyId__"),
						SourcePolicyType: types.PolicySourceType("user"),
						StartPosition: &types.Position{
							Line:   1,
							Column: 1,
						},
						EndPosition: &types.Position{
							Line:   1,
							Column: 1,
						},
					},
					{
						SourcePolicyId:   ptr.String("__SourcePolicyId__"),
						SourcePolicyType: types.PolicySourceType("user"),
						StartPosition: &types.Position{
							Line:   1,
							Column: 1,
						},
						EndPosition: &types.Position{
							Line:   1,
							Column: 1,
						},
					},
				},
				MissingContextValues: []string{
					"__Member__",
					"__Member__",
				},
				OrganizationsDecisionDetail: &types.OrganizationsDecisionDetail{
					AllowedByOrganizations: true,
				},
				PermissionsBoundaryDecisionDetail: &types.PermissionsBoundaryDecisionDetail{
					AllowedByPermissionsBoundary: true,
				},
				EvalDecisionDetails: map[string]types.PolicyEvaluationDecisionType{
					"key0": types.PolicyEvaluationDecisionType("allowed"),
				},
				ResourceSpecificResults: []types.ResourceSpecificResult{
					{
						EvalResourceName:     ptr.String("__EvalResourceName__"),
						EvalResourceDecision: types.PolicyEvaluationDecisionType("allowed"),
						MatchedStatements: []types.Statement{
							{
								SourcePolicyId:   ptr.String("__SourcePolicyId__"),
								SourcePolicyType: types.PolicySourceType("user"),
								StartPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
								EndPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
							},
							{
								SourcePolicyId:   ptr.String("__SourcePolicyId__"),
								SourcePolicyType: types.PolicySourceType("user"),
								StartPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
								EndPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
							},
						},
						MissingContextValues: []string{
							"__Member__",
							"__Member__",
						},
						EvalDecisionDetails: map[string]types.PolicyEvaluationDecisionType{
							"key0": types.PolicyEvaluationDecisionType("allowed"),
						},
						PermissionsBoundaryDecisionDetail: &types.PermissionsBoundaryDecisionDetail{
							AllowedByPermissionsBoundary: true,
						},
					},
					{
						EvalResourceName:     ptr.String("__EvalResourceName__"),
						EvalResourceDecision: types.PolicyEvaluationDecisionType("allowed"),
						MatchedStatements: []types.Statement{
							{
								SourcePolicyId:   ptr.String("__SourcePolicyId__"),
								SourcePolicyType: types.PolicySourceType("user"),
								StartPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
								EndPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
							},
							{
								SourcePolicyId:   ptr.String("__SourcePolicyId__"),
								SourcePolicyType: types.PolicySourceType("user"),
								StartPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
								EndPosition: &types.Position{
									Line:   1,
									Column: 1,
								},
							},
						},
						MissingContextValues: []string{
							"__Member__",
							"__Member__",
						},
						EvalDecisionDetails: map[string]types.PolicyEvaluationDecisionType{
							"key0": types.PolicyEvaluationDecisionType("allowed"),
						},
						PermissionsBoundaryDecisionDetail: &types.PermissionsBoundaryDecisionDetail{
							AllowedByPermissionsBoundary: true,
						},
					},
				},
			},
		},
		IsTruncated: true,
		Marker:      ptr.String("__Marker__"),
	}
	status, header, body, err := serdeRespReadSnapshot("SimulatePrincipalPolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.SimulatePrincipalPolicy(context.Background(), &SimulatePrincipalPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "SimulatePrincipalPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_TagInstanceProfile(t *testing.T) {
	want := &TagInstanceProfileOutput{}
	status, header, body, err := serdeRespReadSnapshot("TagInstanceProfile.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.TagInstanceProfile(context.Background(), &TagInstanceProfileInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "TagInstanceProfile.response", err)
	}
}

func TestCheckResponseSnapshot_TagMFADevice(t *testing.T) {
	want := &TagMFADeviceOutput{}
	status, header, body, err := serdeRespReadSnapshot("TagMFADevice.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.TagMFADevice(context.Background(), &TagMFADeviceInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "TagMFADevice.response", err)
	}
}

func TestCheckResponseSnapshot_TagOpenIDConnectProvider(t *testing.T) {
	want := &TagOpenIDConnectProviderOutput{}
	status, header, body, err := serdeRespReadSnapshot("TagOpenIDConnectProvider.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.TagOpenIDConnectProvider(context.Background(), &TagOpenIDConnectProviderInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "TagOpenIDConnectProvider.response", err)
	}
}

func TestCheckResponseSnapshot_TagPolicy(t *testing.T) {
	want := &TagPolicyOutput{}
	status, header, body, err := serdeRespReadSnapshot("TagPolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.TagPolicy(context.Background(), &TagPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "TagPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_TagRole(t *testing.T) {
	want := &TagRoleOutput{}
	status, header, body, err := serdeRespReadSnapshot("TagRole.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.TagRole(context.Background(), &TagRoleInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "TagRole.response", err)
	}
}

func TestCheckResponseSnapshot_TagSAMLProvider(t *testing.T) {
	want := &TagSAMLProviderOutput{}
	status, header, body, err := serdeRespReadSnapshot("TagSAMLProvider.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.TagSAMLProvider(context.Background(), &TagSAMLProviderInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "TagSAMLProvider.response", err)
	}
}

func TestCheckResponseSnapshot_TagServerCertificate(t *testing.T) {
	want := &TagServerCertificateOutput{}
	status, header, body, err := serdeRespReadSnapshot("TagServerCertificate.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.TagServerCertificate(context.Background(), &TagServerCertificateInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "TagServerCertificate.response", err)
	}
}

func TestCheckResponseSnapshot_TagUser(t *testing.T) {
	want := &TagUserOutput{}
	status, header, body, err := serdeRespReadSnapshot("TagUser.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.TagUser(context.Background(), &TagUserInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "TagUser.response", err)
	}
}

func TestCheckResponseSnapshot_UntagInstanceProfile(t *testing.T) {
	want := &UntagInstanceProfileOutput{}
	status, header, body, err := serdeRespReadSnapshot("UntagInstanceProfile.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UntagInstanceProfile(context.Background(), &UntagInstanceProfileInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UntagInstanceProfile.response", err)
	}
}

func TestCheckResponseSnapshot_UntagMFADevice(t *testing.T) {
	want := &UntagMFADeviceOutput{}
	status, header, body, err := serdeRespReadSnapshot("UntagMFADevice.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UntagMFADevice(context.Background(), &UntagMFADeviceInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UntagMFADevice.response", err)
	}
}

func TestCheckResponseSnapshot_UntagOpenIDConnectProvider(t *testing.T) {
	want := &UntagOpenIDConnectProviderOutput{}
	status, header, body, err := serdeRespReadSnapshot("UntagOpenIDConnectProvider.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UntagOpenIDConnectProvider(context.Background(), &UntagOpenIDConnectProviderInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UntagOpenIDConnectProvider.response", err)
	}
}

func TestCheckResponseSnapshot_UntagPolicy(t *testing.T) {
	want := &UntagPolicyOutput{}
	status, header, body, err := serdeRespReadSnapshot("UntagPolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UntagPolicy(context.Background(), &UntagPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UntagPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_UntagRole(t *testing.T) {
	want := &UntagRoleOutput{}
	status, header, body, err := serdeRespReadSnapshot("UntagRole.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UntagRole(context.Background(), &UntagRoleInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UntagRole.response", err)
	}
}

func TestCheckResponseSnapshot_UntagSAMLProvider(t *testing.T) {
	want := &UntagSAMLProviderOutput{}
	status, header, body, err := serdeRespReadSnapshot("UntagSAMLProvider.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UntagSAMLProvider(context.Background(), &UntagSAMLProviderInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UntagSAMLProvider.response", err)
	}
}

func TestCheckResponseSnapshot_UntagServerCertificate(t *testing.T) {
	want := &UntagServerCertificateOutput{}
	status, header, body, err := serdeRespReadSnapshot("UntagServerCertificate.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UntagServerCertificate(context.Background(), &UntagServerCertificateInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UntagServerCertificate.response", err)
	}
}

func TestCheckResponseSnapshot_UntagUser(t *testing.T) {
	want := &UntagUserOutput{}
	status, header, body, err := serdeRespReadSnapshot("UntagUser.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UntagUser(context.Background(), &UntagUserInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UntagUser.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateAccessKey(t *testing.T) {
	want := &UpdateAccessKeyOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdateAccessKey.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateAccessKey(context.Background(), &UpdateAccessKeyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateAccessKey.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateAccountPasswordPolicy(t *testing.T) {
	want := &UpdateAccountPasswordPolicyOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdateAccountPasswordPolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateAccountPasswordPolicy(context.Background(), &UpdateAccountPasswordPolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateAccountPasswordPolicy.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateAssumeRolePolicy(t *testing.T) {
	want := &UpdateAssumeRolePolicyOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdateAssumeRolePolicy.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateAssumeRolePolicy(context.Background(), &UpdateAssumeRolePolicyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateAssumeRolePolicy.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateDelegationRequest(t *testing.T) {
	want := &UpdateDelegationRequestOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdateDelegationRequest.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateDelegationRequest(context.Background(), &UpdateDelegationRequestInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateDelegationRequest.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateGroup(t *testing.T) {
	want := &UpdateGroupOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdateGroup.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateGroup(context.Background(), &UpdateGroupInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateGroup.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateLoginProfile(t *testing.T) {
	want := &UpdateLoginProfileOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdateLoginProfile.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateLoginProfile(context.Background(), &UpdateLoginProfileInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateLoginProfile.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateOpenIDConnectProviderThumbprint(t *testing.T) {
	want := &UpdateOpenIDConnectProviderThumbprintOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdateOpenIDConnectProviderThumbprint.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateOpenIDConnectProviderThumbprint(context.Background(), &UpdateOpenIDConnectProviderThumbprintInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateOpenIDConnectProviderThumbprint.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateRole(t *testing.T) {
	want := &UpdateRoleOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdateRole.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateRole(context.Background(), &UpdateRoleInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateRole.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateRoleDescription(t *testing.T) {
	want := &UpdateRoleDescriptionOutput{
		Role: &types.Role{
			Path:                     ptr.String("__Path__"),
			RoleName:                 ptr.String("__RoleName__"),
			RoleId:                   ptr.String("__RoleId__"),
			Arn:                      ptr.String("__Arn__"),
			CreateDate:               ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			AssumeRolePolicyDocument: ptr.String("__AssumeRolePolicyDocument__"),
			Description:              ptr.String("__Description__"),
			MaxSessionDuration:       ptr.Int32(1),
			PermissionsBoundary: &types.AttachedPermissionsBoundary{
				PermissionsBoundaryType: types.PermissionsBoundaryAttachmentType("PermissionsBoundaryPolicy"),
				PermissionsBoundaryArn:  ptr.String("__PermissionsBoundaryArn__"),
			},
			Tags: []types.Tag{
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
				{
					Key:   ptr.String("__Key__"),
					Value: ptr.String("__Value__"),
				},
			},
			RoleLastUsed: &types.RoleLastUsed{
				LastUsedDate: ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
				Region:       ptr.String("__Region__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateRoleDescription.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateRoleDescription(context.Background(), &UpdateRoleDescriptionInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateRoleDescription.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateSAMLProvider(t *testing.T) {
	want := &UpdateSAMLProviderOutput{
		SAMLProviderArn: ptr.String("__SAMLProviderArn__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UpdateSAMLProvider.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateSAMLProvider(context.Background(), &UpdateSAMLProviderInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateSAMLProvider.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateSSHPublicKey(t *testing.T) {
	want := &UpdateSSHPublicKeyOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdateSSHPublicKey.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateSSHPublicKey(context.Background(), &UpdateSSHPublicKeyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateSSHPublicKey.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateServerCertificate(t *testing.T) {
	want := &UpdateServerCertificateOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdateServerCertificate.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateServerCertificate(context.Background(), &UpdateServerCertificateInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateServerCertificate.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateServiceSpecificCredential(t *testing.T) {
	want := &UpdateServiceSpecificCredentialOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdateServiceSpecificCredential.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateServiceSpecificCredential(context.Background(), &UpdateServiceSpecificCredentialInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateServiceSpecificCredential.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateSigningCertificate(t *testing.T) {
	want := &UpdateSigningCertificateOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdateSigningCertificate.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateSigningCertificate(context.Background(), &UpdateSigningCertificateInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateSigningCertificate.response", err)
	}
}

func TestCheckResponseSnapshot_UpdateUser(t *testing.T) {
	want := &UpdateUserOutput{}
	status, header, body, err := serdeRespReadSnapshot("UpdateUser.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UpdateUser(context.Background(), &UpdateUserInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UpdateUser.response", err)
	}
}

func TestCheckResponseSnapshot_UploadSSHPublicKey(t *testing.T) {
	want := &UploadSSHPublicKeyOutput{
		SSHPublicKey: &types.SSHPublicKey{
			UserName:         ptr.String("__UserName__"),
			SSHPublicKeyId:   ptr.String("__SSHPublicKeyId__"),
			Fingerprint:      ptr.String("__Fingerprint__"),
			SSHPublicKeyBody: ptr.String("__SSHPublicKeyBody__"),
			Status:           types.StatusType("Active"),
			UploadDate:       ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UploadSSHPublicKey.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UploadSSHPublicKey(context.Background(), &UploadSSHPublicKeyInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UploadSSHPublicKey.response", err)
	}
}

func TestCheckResponseSnapshot_UploadServerCertificate(t *testing.T) {
	want := &UploadServerCertificateOutput{
		ServerCertificateMetadata: &types.ServerCertificateMetadata{
			Path:                  ptr.String("__Path__"),
			ServerCertificateName: ptr.String("__ServerCertificateName__"),
			ServerCertificateId:   ptr.String("__ServerCertificateId__"),
			Arn:                   ptr.String("__Arn__"),
			UploadDate:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
			Expiration:            ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
		Tags: []types.Tag{
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
			{
				Key:   ptr.String("__Key__"),
				Value: ptr.String("__Value__"),
			},
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UploadServerCertificate.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UploadServerCertificate(context.Background(), &UploadServerCertificateInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UploadServerCertificate.response", err)
	}
}

func TestCheckResponseSnapshot_UploadSigningCertificate(t *testing.T) {
	want := &UploadSigningCertificateOutput{
		Certificate: &types.SigningCertificate{
			UserName:        ptr.String("__UserName__"),
			CertificateId:   ptr.String("__CertificateId__"),
			CertificateBody: ptr.String("__CertificateBody__"),
			Status:          types.StatusType("Active"),
			UploadDate:      ptr.Time(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)),
		},
	}
	status, header, body, err := serdeRespReadSnapshot("UploadSigningCertificate.response")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	got, err := svc.UploadSigningCertificate(context.Background(), &UploadSigningCertificateInput{})
	if err != nil {
		t.Fatal(err)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("response snapshot mismatch for %s: %v", "UploadSigningCertificate.response", err)
	}
}

func TestCheckResponseSnapshot_Error_AccountNotManagementOrDelegatedAdministratorException(t *testing.T) {
	want := &types.AccountNotManagementOrDelegatedAdministratorException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("AccountNotManagementOrDelegatedAdministratorException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.DisableOrganizationsRootCredentialsManagement(context.Background(), &DisableOrganizationsRootCredentialsManagementInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.AccountNotManagementOrDelegatedAdministratorException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.AccountNotManagementOrDelegatedAdministratorException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "AccountNotManagementOrDelegatedAdministratorException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_CallerIsNotManagementAccountException(t *testing.T) {
	want := &types.CallerIsNotManagementAccountException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CallerIsNotManagementAccountException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.EnableOrganizationsRootCredentialsManagement(context.Background(), &EnableOrganizationsRootCredentialsManagementInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.CallerIsNotManagementAccountException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.CallerIsNotManagementAccountException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "CallerIsNotManagementAccountException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ConcurrentModificationException(t *testing.T) {
	want := &types.ConcurrentModificationException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ConcurrentModificationException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.AcceptDelegationRequest(context.Background(), &AcceptDelegationRequestInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ConcurrentModificationException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ConcurrentModificationException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ConcurrentModificationException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_CredentialReportExpiredException(t *testing.T) {
	want := &types.CredentialReportExpiredException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CredentialReportExpiredException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.GetCredentialReport(context.Background(), &GetCredentialReportInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.CredentialReportExpiredException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.CredentialReportExpiredException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "CredentialReportExpiredException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_CredentialReportNotPresentException(t *testing.T) {
	want := &types.CredentialReportNotPresentException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CredentialReportNotPresentException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.GetCredentialReport(context.Background(), &GetCredentialReportInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.CredentialReportNotPresentException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.CredentialReportNotPresentException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "CredentialReportNotPresentException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_CredentialReportNotReadyException(t *testing.T) {
	want := &types.CredentialReportNotReadyException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("CredentialReportNotReadyException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.GetCredentialReport(context.Background(), &GetCredentialReportInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.CredentialReportNotReadyException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.CredentialReportNotReadyException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "CredentialReportNotReadyException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_DeleteConflictException(t *testing.T) {
	want := &types.DeleteConflictException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DeleteConflictException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.DeleteGroup(context.Background(), &DeleteGroupInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.DeleteConflictException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.DeleteConflictException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "DeleteConflictException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_DuplicateCertificateException(t *testing.T) {
	want := &types.DuplicateCertificateException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DuplicateCertificateException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.UploadSigningCertificate(context.Background(), &UploadSigningCertificateInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.DuplicateCertificateException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.DuplicateCertificateException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "DuplicateCertificateException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_DuplicateSSHPublicKeyException(t *testing.T) {
	want := &types.DuplicateSSHPublicKeyException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("DuplicateSSHPublicKeyException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.UploadSSHPublicKey(context.Background(), &UploadSSHPublicKeyInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.DuplicateSSHPublicKeyException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.DuplicateSSHPublicKeyException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "DuplicateSSHPublicKeyException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_EntityAlreadyExistsException(t *testing.T) {
	want := &types.EntityAlreadyExistsException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("EntityAlreadyExistsException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.AddRoleToInstanceProfile(context.Background(), &AddRoleToInstanceProfileInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.EntityAlreadyExistsException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.EntityAlreadyExistsException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "EntityAlreadyExistsException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_EntityTemporarilyUnmodifiableException(t *testing.T) {
	want := &types.EntityTemporarilyUnmodifiableException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("EntityTemporarilyUnmodifiableException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.ChangePassword(context.Background(), &ChangePasswordInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.EntityTemporarilyUnmodifiableException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.EntityTemporarilyUnmodifiableException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "EntityTemporarilyUnmodifiableException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_FeatureDisabledException(t *testing.T) {
	want := &types.FeatureDisabledException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("FeatureDisabledException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.DisableOutboundWebIdentityFederation(context.Background(), &DisableOutboundWebIdentityFederationInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.FeatureDisabledException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.FeatureDisabledException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "FeatureDisabledException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_FeatureEnabledException(t *testing.T) {
	want := &types.FeatureEnabledException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("FeatureEnabledException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.EnableOutboundWebIdentityFederation(context.Background(), &EnableOutboundWebIdentityFederationInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.FeatureEnabledException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.FeatureEnabledException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "FeatureEnabledException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidAuthenticationCodeException(t *testing.T) {
	want := &types.InvalidAuthenticationCodeException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidAuthenticationCodeException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.EnableMFADevice(context.Background(), &EnableMFADeviceInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidAuthenticationCodeException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidAuthenticationCodeException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidAuthenticationCodeException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidCertificateException(t *testing.T) {
	want := &types.InvalidCertificateException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidCertificateException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.UploadSigningCertificate(context.Background(), &UploadSigningCertificateInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidCertificateException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidCertificateException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidCertificateException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidInputException(t *testing.T) {
	want := &types.InvalidInputException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidInputException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.AddClientIDToOpenIDConnectProvider(context.Background(), &AddClientIDToOpenIDConnectProviderInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidInputException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidInputException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidInputException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidPublicKeyException(t *testing.T) {
	want := &types.InvalidPublicKeyException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidPublicKeyException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.UploadSSHPublicKey(context.Background(), &UploadSSHPublicKeyInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidPublicKeyException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidPublicKeyException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidPublicKeyException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_InvalidUserTypeException(t *testing.T) {
	want := &types.InvalidUserTypeException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("InvalidUserTypeException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.ChangePassword(context.Background(), &ChangePasswordInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.InvalidUserTypeException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.InvalidUserTypeException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "InvalidUserTypeException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_KeyPairMismatchException(t *testing.T) {
	want := &types.KeyPairMismatchException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("KeyPairMismatchException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.UploadServerCertificate(context.Background(), &UploadServerCertificateInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.KeyPairMismatchException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.KeyPairMismatchException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "KeyPairMismatchException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_LimitExceededException(t *testing.T) {
	want := &types.LimitExceededException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("LimitExceededException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.AddClientIDToOpenIDConnectProvider(context.Background(), &AddClientIDToOpenIDConnectProviderInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.LimitExceededException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.LimitExceededException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "LimitExceededException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_MalformedCertificateException(t *testing.T) {
	want := &types.MalformedCertificateException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("MalformedCertificateException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.UploadServerCertificate(context.Background(), &UploadServerCertificateInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.MalformedCertificateException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.MalformedCertificateException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "MalformedCertificateException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_MalformedPolicyDocumentException(t *testing.T) {
	want := &types.MalformedPolicyDocumentException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("MalformedPolicyDocumentException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.CreatePolicy(context.Background(), &CreatePolicyInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.MalformedPolicyDocumentException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.MalformedPolicyDocumentException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "MalformedPolicyDocumentException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_NoSuchEntityException(t *testing.T) {
	want := &types.NoSuchEntityException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("NoSuchEntityException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.AcceptDelegationRequest(context.Background(), &AcceptDelegationRequestInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.NoSuchEntityException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.NoSuchEntityException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "NoSuchEntityException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_OpenIdIdpCommunicationErrorException(t *testing.T) {
	want := &types.OpenIdIdpCommunicationErrorException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("OpenIdIdpCommunicationErrorException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.CreateOpenIDConnectProvider(context.Background(), &CreateOpenIDConnectProviderInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.OpenIdIdpCommunicationErrorException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.OpenIdIdpCommunicationErrorException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "OpenIdIdpCommunicationErrorException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_OrganizationNotFoundException(t *testing.T) {
	want := &types.OrganizationNotFoundException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("OrganizationNotFoundException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.DisableOrganizationsRootCredentialsManagement(context.Background(), &DisableOrganizationsRootCredentialsManagementInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.OrganizationNotFoundException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.OrganizationNotFoundException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "OrganizationNotFoundException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_OrganizationNotInAllFeaturesModeException(t *testing.T) {
	want := &types.OrganizationNotInAllFeaturesModeException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("OrganizationNotInAllFeaturesModeException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.DisableOrganizationsRootCredentialsManagement(context.Background(), &DisableOrganizationsRootCredentialsManagementInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.OrganizationNotInAllFeaturesModeException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.OrganizationNotInAllFeaturesModeException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "OrganizationNotInAllFeaturesModeException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_PasswordPolicyViolationException(t *testing.T) {
	want := &types.PasswordPolicyViolationException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("PasswordPolicyViolationException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.ChangePassword(context.Background(), &ChangePasswordInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.PasswordPolicyViolationException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.PasswordPolicyViolationException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "PasswordPolicyViolationException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_PolicyEvaluationException(t *testing.T) {
	want := &types.PolicyEvaluationException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("PolicyEvaluationException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.SimulateCustomPolicy(context.Background(), &SimulateCustomPolicyInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.PolicyEvaluationException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.PolicyEvaluationException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "PolicyEvaluationException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_PolicyNotAttachableException(t *testing.T) {
	want := &types.PolicyNotAttachableException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("PolicyNotAttachableException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.AttachGroupPolicy(context.Background(), &AttachGroupPolicyInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.PolicyNotAttachableException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.PolicyNotAttachableException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "PolicyNotAttachableException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ReportGenerationLimitExceededException(t *testing.T) {
	want := &types.ReportGenerationLimitExceededException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ReportGenerationLimitExceededException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.GenerateOrganizationsAccessReport(context.Background(), &GenerateOrganizationsAccessReportInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ReportGenerationLimitExceededException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ReportGenerationLimitExceededException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ReportGenerationLimitExceededException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ServiceAccessNotEnabledException(t *testing.T) {
	want := &types.ServiceAccessNotEnabledException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ServiceAccessNotEnabledException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.DisableOrganizationsRootCredentialsManagement(context.Background(), &DisableOrganizationsRootCredentialsManagementInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ServiceAccessNotEnabledException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ServiceAccessNotEnabledException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ServiceAccessNotEnabledException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ServiceFailureException(t *testing.T) {
	want := &types.ServiceFailureException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ServiceFailureException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.AcceptDelegationRequest(context.Background(), &AcceptDelegationRequestInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ServiceFailureException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ServiceFailureException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ServiceFailureException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_ServiceNotSupportedException(t *testing.T) {
	want := &types.ServiceNotSupportedException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("ServiceNotSupportedException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.CreateServiceSpecificCredential(context.Background(), &CreateServiceSpecificCredentialInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.ServiceNotSupportedException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.ServiceNotSupportedException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "ServiceNotSupportedException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_UnmodifiableEntityException(t *testing.T) {
	want := &types.UnmodifiableEntityException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UnmodifiableEntityException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.AddRoleToInstanceProfile(context.Background(), &AddRoleToInstanceProfileInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.UnmodifiableEntityException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.UnmodifiableEntityException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "UnmodifiableEntityException.error", err)
	}
}

func TestCheckResponseSnapshot_Error_UnrecognizedPublicKeyEncodingException(t *testing.T) {
	want := &types.UnrecognizedPublicKeyEncodingException{
		Message: ptr.String("__Message__"),
	}
	status, header, body, err := serdeRespReadSnapshot("UnrecognizedPublicKeyEncodingException.error")
	if errors.Is(err, fs.ErrNotExist) {
		t.Skip("no response snapshot fixture")
	}
	if err != nil {
		t.Fatal(err)
	}
	svc := serdeRespClient(status, header, body)
	_, opErr := svc.GetSSHPublicKey(context.Background(), &GetSSHPublicKeyInput{})
	if opErr == nil {
		t.Fatal("expected error, got nil")
	}
	var got *types.UnrecognizedPublicKeyEncodingException
	if !errors.As(opErr, &got) {
		t.Fatalf("expected types.UnrecognizedPublicKeyEncodingException, got %v", opErr)
	}
	if err := smithytesting.CompareValues(want, got); err != nil {
		t.Errorf("error response snapshot mismatch for %s: %v", "UnrecognizedPublicKeyEncodingException.error", err)
	}
}